﻿using System;
using System.ComponentModel;
using System.Linq;
using System.NetFramework;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

#region VB6.0に関するオブジェクトを保有するネームスペース
namespace VB60
{
    #region 列挙体

    #region 描写系
    /// <summary>既定されたVBカラー(ARGB型)</summary> 
    public enum ColorConstants : int
    {
        /// <summary>黒</summary> 
        vbBlack = unchecked((int)0xff000000),
        /// <summary>青</summary> 
        vbBlue = unchecked((int)0xff0000ff),
        /// <summary>緑</summary> 
        vbGreen = unchecked((int)0xff00ff00),
        /// <summary>シアン</summary> 
        vbCyan = unchecked((int)0xff00ffff),
        /// <summary>赤</summary> 
        vbRed = unchecked((int)0xffff0000),
        /// <summary>マゼンタ</summary> 
        vbMagenta = unchecked((int)0xffff00ff),
        /// <summary>黄</summary> 
        vbYellow = unchecked((int)0xffffff00),
        /// <summary>白</summary> 
        vbWhite = unchecked((int)0xffffffff)
    }

    /// <summary>線のスタイル</summary> 
    public enum DrawStyleConstants
    {
        /// <summary>実線</summary> 
        vbSolid,
        /// <summary>ダッシュで構成される直線</summary> 
        vbDash,
        /// <summary>ドットで構成される直線</summary> 
        vbDot,
        /// <summary>ダッシュとドットの繰り返しパターンで構成される直線</summary> 
        vbDashDot,
        /// <summary>ダッシュと 2 つのドットの繰り返しパターンで構成される直線</summary> 
        vbDashDotDot
    }

    /// <summary>グラフィックススタイル</summary>
    [Microsoft.VisualBasic.CompilerServices.StandardModule()]
    public static class GraphicsStyle
    {
        /// <summary>直線を描くときのスタイル</summary>
        public enum LineStyle
        {
            /// <summary>直線</summary>
            Line,
            /// <summary>長方形</summary>
            Rectangle,
            /// <summary>塗りつぶしの長方形</summary>
            FillRectangle,
            /// <summary>長方形</summary>
            B = Rectangle,
            /// <summary>塗りつぶしの長方形</summary>
            BF = FillRectangle
        }

        /// <summary>円を描くときのスタイル</summary>
        public enum CircleStyle
        {
            /// <summary>扇型</summary>
            Pie,
            /// <summary>円弧</summary>
            Arc,
            /// <summary>塗りつぶしの扇型</summary>
            FillPie
        }

        /// <summary>円を描くときのスタイル</summary>
        public enum ObjectCircleStyle
        {
            /// <summary>円</summary>
            Circle,
            /// <summary>塗りつぶしの円</summary>
            FillCircle
        }
    }

    /// <summary>塗りつぶしのスタイル</summary>
    public enum FillStyleConstants
    {
        /// <summary>塗りつぶし</summary> 
        vbFSSolid,
        /// <summary>透明</summary> 
        vbFSTransparent,
        /// <summary>横線</summary> 
        vbHorizontalLine,
        /// <summary>縦線</summary> 
        vbVerticalLine,
        /// <summary>斜線(左上-右下)</summary>
        vbUpwardDiagonal,
        /// <summary>斜線(左下-右上)</summary>
        vbDownwardDiagonal,
        /// <summary>クロス</summary>
        vbCross,
        /// <summary>網掛け</summary>
        vbDiagonalCross
    }

    /// <summary>ラスターオペレーション(画像合成の方法)</summary>
    /// <remarks>この列挙体で出てくる説明の中の記号は以下の通り
    /// <para>Dest:デスティネーションビットマップ(転送先のビットマップ)</para>
    /// <para>Src:ソースビットマップ(転送元のビットマップ)</para>
    /// <para>Pat:パターンカラー(転送先で設定されているパターンカラー)</para></remarks>
    public enum RasterOpConstants : int
    {
        /// <summary>Dest α Src : ディスティネーションビットマップとソースビットマップをαブレンド</summary>
        vbSrcAlpha,
        /// <summary>Dest + Src : ディスティネーションビットマップにソースビットマップを加算(+)</summary>
        vbSrcAdd,
        /// <summary>Dest - Src : ディスティネーションビットマップからソースビットマップを減算(-)</summary>
        vbSrcSub,
        /// <summary>Dest * Src : ディスティネーションビットマップにソースビットマップを乗算(*)</summary>
        vbSrcMul,
        /// <summary>Dest / Src : ディスティネーションビットマップからソースビットマップを除算(/)</summary>
        vbSrcDiv,
        /// <summary>Src : ソースビットマップを、デスティネーションビットマップにコピー</summary>
        vbSrcCopy = 0xcc0020,
        /// <summary>Dest OR Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(OR)</summary>
        vbSrcPaint = 0xee0086,
        /// <summary>Dest And Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(AND)</summary>
        vbSrcAnd = 0x8800c6,
        /// <summary>Dest XOR Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(XOR)</summary>
        vbSrcInvert = 0x660046,
        /// <summary>NOT Dest AND Src : デスティネーションビットマップを反転させた結果と、ソースビットマップのピクセルを合成(AND)</summary>
        vbSrcErase = 0x440328,
        /// <summary>NOT Src : ソースビットマップを反転させた結果を、デスティネーションビットマップにコピー</summary>
        vbNotSrcCopy = 0x330008,
        /// <summary>NOT (Dest OR Src) : デスティネーションビットマップと、ソースビットマップのピクセルを合成した結果を反転(OR)</summary>
        vbNotSrcErase = 0x1100a6,
        /// <summary>Pat AND Src : パターンとソースビットマップを合成(AND)</summary>
        vbMergeCopy = 0xc000ca,
        /// <summary>Dest OR Not Src : 反転したソースビットマップをデスティネーションビットマップに合成(OR)</summary>
        vbMergePaint = 0xbb0226,
        /// <summary>Pat : パターンをデスティネーションビットマップにコピー</summary>
        vbPatCopy = 0xf00021,
        /// <summary>Dest OR Pat : デスティネーションビットマップをパターンと合成(OR)</summary>
        vbPatPaint = 0xfb0a09,
        /// <summary>Dest XOR Pat : パターンをデスティネーションビットマップと合成(XOR)</summary>
        vbPatInvert = 0x5a0049,
        /// <summary>NOT Dest : デスティネーションビットマップを反転</summary>
        vbDstInvert = 0x550009,
        /// <summary>Black : 黒で塗りつぶす</summary>
        vbBlackness = 0x42,
        /// <summary>White : 白で塗りつぶす</summary>
        vbWhiteness = 0xff0062
    }
    #endregion

    #region その他
    /// <summary>仮想座標のモード</summary> 
    public enum ScaleModeConstants
    {
        /// <summary>Scale～の設定を使う</summary> 
        vbUser,
        /// <summary>Twip (1 インチ当たり 1,440 twip、1 センチ当たり 567 twip)</summary> 
        vbTwips,
        /// <summary>ポイント (1 論理インチ当たり 72 ポイント)</summary> 
        vbPoints,
        /// <summary>ピクセル (モニタまたはプリンタの解像度の最小単位)</summary> 
        vbPixels,
        /// <summary>文字 (水平方向 = 1 単位当たり 120 twip、垂直方向 = 1 単位当たり 240 twip)</summary> 
        vbCharacters,
        /// <summary>インチ(dpiに依存)</summary> 
        vbInches,
        /// <summary>ミリメートル (mm)</summary> 
        vbMillimeters,
        /// <summary>センチメートル (cm)</summary> 
        vbCentimeters,
        /// <summary>HiMetric (1 単位当たり0.01mm)</summary> 
        VbHimetric
    }

    //軸の方向を示すネームスペース
    namespace AxialDirectionConstants
    {
        /// <summary>X軸の方向</summary>
        public enum XAxial
        {
            /// <summary>右</summary>
            Right,
            /// <summary>左</summary>
            Left
        }

        /// <summary>Y軸の方向</summary>
        public enum YAxial
        {
            /// <summary>下</summary>
            Bottom,
            /// <summary>上</summary>
            Top
        }
    }
    #endregion

    #endregion

    #region Informationモジュール
    /// <summary>VB6.0のInformationの一部のモジュールを提供します。</summary>
    /// <remarks>Information.QBColor(1) VB6.0のQBColor(1)と同等</remarks>
    [Microsoft.VisualBasic.CompilerServices.StandardModule()]
    public static class Information
    {
        /// <summary>ColorConstants型の色情報をColor構造体に変換する</summary>
        /// <param name="Obj">ColorConstants型の変換対象</param>
        /// <returns>変換後のColor構造体</returns>
        public static Color ToColor(this ColorConstants Obj)
        {
            int tmp = (int)Obj;
            return Color.FromArgb((byte)(tmp >> 24), (byte)(tmp >> 16), (byte)(tmp >> 8), (byte)tmp);
        }

        /// <summary>赤・緑・青それぞれの値から色を作る(ARGB形式)</summary>
        /// <param name="Red">赤の強さ(0～255の範囲)</param>
        /// <param name="Green">緑の強さ(0～255の範囲)</param>
        /// <param name="Blue">青の強さ(0～255の範囲)</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.RGB(100,100,100) VB6.0のRGB(100,100,100)と同等</para>
        /// </example></remarks>
        public static ColorConstants RGB(byte Red, byte Green, byte Blue)
        {
            return (ColorConstants)((255 << 24) | (Red << 16) | (Green << 8) | Blue);
        }

        /// <summary>アルファ・赤・緑・青それぞれの値から色を作る(ARGB形式)</summary>
        /// <param name="Alpha">不透明度の強さ(0～255の範囲)</param>
        /// <param name="Red">赤の強さ(0～255の範囲)</param>
        /// <param name="Green">緑の強さ(0～255の範囲)</param>
        /// <param name="Blue">青の強さ(0～255の範囲)</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.ARGB(100,100,100,100) Color.FromArgb(100, 100, 100, 100).ToArgb()と同等(ただしARGB形式で扱う)</para>
        /// </example></remarks>
        public static ColorConstants ARGB(byte Alpha, byte Red, byte Green, byte Blue)
        {
            return (ColorConstants)((Alpha << 24) | (Red << 16) | (Green << 8) | Blue);
        }

        /// <summary>アルファ・既定色そから不透明度を設定しなおして色を作る(ARGB形式)</summary>
        /// <param name="Alpha">不透明度の強さ(0～255の範囲)</param>
        /// <param name="BaseColor">ベースとなる既定色</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.ARGB(100,ColorConstants.Black) Color.FromArgb(100, Color.Black).ToArgb()と同等(ただしARGB形式で扱う)</para>
        /// </example></remarks>
        public static ColorConstants ARGB(byte Alpha, ColorConstants BaseColor)
        {
            return (ColorConstants)((Alpha << 24) | (0xffffff & (int)BaseColor));
        }

        /// <summary>あらかじめ決められた色を取得する(ARGB形式)</summary> 
        /// <param name="VBColor">VB6.0の識別の整数(0～15) それ以外の範囲は透明色を返す</param> 
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>Information.QBColor(0) VB6.0のQBColor(0)と同等</para> 
        /// </example></remarks>
        public static ColorConstants QBColor(int VBColor)
        {
            long ARGB = 0;

            switch (VBColor)
            {
                case 0:
                    ARGB = 0xff000000;
                    break;

                case 1:
                    ARGB = 0xff000080;
                    break;

                case 2:
                    ARGB = 0xff008000;
                    break;

                case 3:
                    ARGB = 0xff008080;
                    break;

                case 4:
                    ARGB = 0xff800000;
                    break;

                case 5:
                    ARGB = 0xff800080;
                    break;

                case 6:
                    ARGB = 0xff808000;
                    break;

                case 7:
                    ARGB = 0xffc0c0c0;
                    break;

                case 8:
                    ARGB = 0xff808080;
                    break;

                case 9:
                    ARGB = 0xff0000ff;
                    break;

                case 10:
                    ARGB = 0xff00ff00;
                    break;

                case 11:
                    ARGB = 0xff00ffff;
                    break;

                case 12:
                    ARGB = 0xffff0000;
                    break;

                case 13:
                    ARGB = 0xffff00ff;
                    break;

                case 14:
                    ARGB = 0xffffff00;
                    break;

                case 15:
                    ARGB = 0xffffffff;
                    break;

                default:
                    ARGB = 0x00000000;
                    break;
            }

            return unchecked((ColorConstants)ARGB);
        }
    }
    #endregion

    #region NullableClassクラス
    /// <summary>Nullable型のクラス版</summary>
    /// <typeparam name="T">NullableClass基となる値型</typeparam>
    public class NullableClass<T>
        where T : struct
    {
        /// <summary>保持している値</summary>
        public T Value { get; set; }

        /// <summary>コンストラクタ</summary>
        /// <param name="Value">初期値</param>
        public NullableClass(T Value)
        {
            this.Value = Value;
        }

        /// <summary>NullableClassからTへ変換する</summary>
        /// <param name="Obj">Tに変換するNullableClass</param>
        /// <returns>T型の値</returns>
        public static implicit operator T(NullableClass<T> Obj)
        {
            return Obj.Value;
        }

        /// <summary>TからNullableClassへ変換する</summary>
        /// <param name="Obj">NullableClassに変換するT</param>
        /// <returns>NullableClass型の値</returns>
        public static implicit operator NullableClass<T>(T Obj)
        {
            return new NullableClass<T>(Obj);
        }

        /// <summary>NullableClassからNullableへ変換する</summary>
        /// <param name="Obj">Nullableに変換するNullableClass</param>
        /// <returns>Nullable型の値</returns>
        public static implicit operator Nullable<T>(NullableClass<T> Obj)
        {
            return (Obj == null ? (Nullable<T>)null : Obj.Value);
        }

        /// <summary>NullableからNullableClassへ変換する</summary>
        /// <param name="Obj">NullableClassに変換するNullable</param>
        /// <returns>NullableClass型の値</returns>
        public static implicit operator NullableClass<T>(Nullable<T> Obj)
        {
            return (Obj.HasValue == false ? (NullableClass<T>)null : (NullableClass<T>)Obj.Value);
        }

        /// <summary>現在のNullableClassオブジェクトが指定されたオブジェクトと等しいかどうかを返す</summary>
        /// <param name="obj">比較するオブジェクト</param>
        /// <returns>other パラメーターが現在のNullableClassオブジェクトと等しい場合はtrue 等しくない場合はfalse</returns>
        public override bool Equals(object obj)
        {
            return this.Value.Equals(obj);
        }

        /// <summary>現在のNullableClassオブジェクトの値のテキスト形式を返す</summary>
        /// <returns>現在の値のテキスト形式</returns>
        public override string ToString()
        {
            return this.Value.ToString();
        }

        /// <summary>NullableClassのValue プロパティから返されるオブジェクトのハッシュコードを取得する</summary>
        /// <returns>プロパティから返されるオブジェクトのハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.Value.GetHashCode();
        }
    }

    /// <summary>NullableClassの拡張メソッド</summary>
    public static class NullableClassExtension
    {
        /// <summary>NullableClassオブジェクトに値があるかどうかを示す値を取得する</summary>
        /// <typeparam name="T">NullableClassオブジェクトの基となる値型</typeparam>
        /// <param name="Obj">対象のNullableClass</param>
        /// <returns>オブジェクトに値があるかどうか</returns>
        public static bool HasValue<T>(this NullableClass<T> Obj)
            where T : struct
        {
            return Obj != null;
        }

        /// <summary>NullableClassオブジェクトの値、またはこのオブジェクトの既定値を取得する</summary>
        /// <typeparam name="T">NullableClassオブジェクトの基となる値型</typeparam>
        /// <param name="Obj">対象のNullableClass</param>
        /// <returns>NullableClass.HasValueがtrueの場合はNullableClass.Valueプロパティの値 それ以外の場合は現在のNullableClassオブジェクトの既定値 既定値の型は、現在のNullableClassオブジェクトの型引数</returns>
        public static T GetValueOrDefault<T>(this NullableClass<T> Obj)
            where T : struct
        {
            return (Obj == null ? default(T) : Obj.Value);
        }

        /// <summary>NullableClassオブジェクトの値、または指定した既定値を取得する</summary>
        /// <typeparam name="T">NullableClassオブジェクトの基となる値型</typeparam>
        /// <param name="Obj">対象のNullableClass</param>
        /// <param name="DefaultValue">NullableClass.HasValueがfalseの場合に返す値</param>
        /// <returns>NullableClass.HasValueがtrueの場合はNullableClass.Valueプロパティの値 それ以外の場合はDefaultValueパラメータ</returns>
        public static T GetValueOrDefault<T>(this NullableClass<T> Obj, T DefaultValue)
            where T : struct
        {
            return (Obj == null ? DefaultValue : Obj.Value);
        }
    }
    #endregion

    #region PictureBoxクラス
    /// <summary>VB6.0のPictureBoxとほぼ同等なPictureBox</summary>
    /// <remarks>
    /// クラスの利用方法(VB.NET) C#での引数途中省略は引数にnullを指定する PictureBox.Circle(0,0,1,null,null,null,2);
    /// <para>宣言と初期化　　　　：Dim A As VB60.PictureBox = New VB60.PictureBox()</para>
    /// <para>座標軸の方向設定　　：A.YAxialDirection = AxialDirectionConstants.YAxial.Top等</para>
    /// <para>仮想座標の設定　　　：A.Init_Scale(-1,1,2,2) →数学座標の-1～1の幅高さそれぞれ2の仮想座標の設定</para>
    /// <para>使う前の最後の初期化：A.Starting_Init()</para>
    /// <para>実際に使用する　　　：A.Line(X1,Y1,X2,Y2)等</para>
    /// <para>外部から操作する　　：A.Interrupt()→外部操作→A.Interrupt()</para>
    /// </remarks>
    [Description("VB6.0のPictureBoxとほぼ同等なPictureBoxを提供します。")]
    public class PictureBox : System.NetFramework.PictureBox
    {
        #region フィールド
        private bool StartEnabledFlag;
        private bool InterruptFlag;
        private double SW;
        private double SH;
        private double ST;
        private double SL;
        private ScaleModeConstants SM;
        private double NowX;
        private double NowY;
        private FillStyleConstants FStyle;
        private bool ARedraw;
        private AxialDirectionConstants.XAxial XAD;
        private AxialDirectionConstants.YAxial YAD;
        private System.NetFramework.CompositingMode DrawCMode;
        private System.NetFramework.SmoothingMode DrawSMode;
        private Color PColor;
        private PictureBoxUnitConvert Converter;
        /// <summary>描画対象=基底クラスのImageに代入</summary>
        internal WriteableBitmap ScaleImage;
        /// <summary>描画対象のGraphicsオブジェクト</summary>
        internal System.NetFramework.RVGraphics TargetGraphics;
        /// <summary>描画時に使うPen</summary>
        internal System.NetFramework.Pen DrawPen;
        /// <summary>描画に使うフォント</summary>
        private System.NetFramework.Font DFont;
        /// <summary>塗りつぶし時に使うブラシ</summary>
        internal System.NetFramework.HatchBrush FillBrush;
        /// <summary>ベクターグラフィックスの編集クラス</summary>
        private PictureBoxEditVector EK, EA;
        #endregion

        #region プロパティ

        #region 仮想座標系
        /// <summary>仮想座標の幅(マイナスの値の場合はX軸の方向がLeftになる)</summary>
        [Category("仮想座標"), DefaultValue(100.0), Description("仮想座標の幅を入力・取得します。(マイナスの値の場合はX軸の方向がLeftになる)")]
        public double ScaleWidth
        {
            get { return this.SW; }

            set
            {
                this.SW = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の高さ(マイナスの値の場合はY軸の方向がTopになる)</summary>
        [Category("仮想座標"), DefaultValue(100.0), Description("仮想座標の高さの値を入力・取得します。(マイナスの値の場合はY軸の方向がTopになる)")]
        public double ScaleHeight
        {
            get { return this.SH; }

            set
            {
                this.SH = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の上端の値</summary>
        [Category("仮想座標"), DefaultValue(0.0), Description("仮想座標の上端の値を入力・取得します。")]
        public double ScaleTop
        {
            get { return this.ST; }

            set
            {
                this.ST = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の左端の値</summary>
        [Category("仮想座標"), DefaultValue(0.0), Description("仮想座標の左端の値を入力・取得します。")]
        public double ScaleLeft
        {
            get { return this.SL; }

            set
            {
                this.SL = value;
                Init_CurrentValue();
            }
        }

        /// <summary>X軸の方向(Xのプラス方向)</summary>
        [Category("仮想座標"), DefaultValue(AxialDirectionConstants.XAxial.Right), Description("仮想座標のX軸の方向(プラス側)をAxialDirectionConstants.XAxial形式で入力・取得します。")]
        public AxialDirectionConstants.XAxial XAxialDirection
        {
            get { return this.XAD; }

            set
            {
                this.XAD = value;
                Init_CurrentValue();
            }
        }

        /// <summary>Y軸の方向(Yのプラス方向)</summary>
        [Category("仮想座標"), DefaultValue(AxialDirectionConstants.YAxial.Bottom), Description("仮想座標のY軸の方向(プラス側)をAxialDirectionConstants.YAxial形式で入力・取得します。")]
        public AxialDirectionConstants.YAxial YAxialDirection
        {
            get { return this.YAD; }

            set
            {
                this.YAD = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標のモード</summary>
        [Category("仮想座標"), DefaultValue(ScaleModeConstants.vbPixels), Description("仮想座標のモードをScaleModeConstants形式で入力・取得します。")]
        public ScaleModeConstants ScaleMode
        {
            get { return this.SM; }

            set
            {
                this.SM = value;
                Init_CurrentValue();
            }
        }
        #endregion

        #region 描写系
        /// <summary>描写位置X</summary>
        [Category("VB描写"), Description("次の描写で書き始める座標位置Xを入力・取得します。")]
        public double CurrentX
        {
            get { return this.NowX; }

            set { this.NowX = value; }
        }

        /// <summary>描写位置Y</summary>
        [Category("VB描写"), Description("次の描写で書き始める座標位置Yを入力・取得します。")]
        public double CurrentY
        {
            get { return this.NowY; }

            set { this.NowY = value; }
        }

        /// <summary>直線や円を描く時の線の色(ColorConstants形式(ARGB形式))</summary>
        [Category("VB描写"), DefaultValue(ColorConstants.vbBlack), Description("直線や円を描く時の線の色をColorConstants形式(ARGB形式)で入力・取得します。")]
        public ColorConstants ForeColor
        {
            get { return (ColorConstants)this.DrawPen.Color.ToArgb(); }

            set { this.DrawPen.Color = ((int)value).ToColor(); }
        }

        /// <summary>直線や円を描く時の線の太さ(0.0以下は代入不可)</summary>
        [Category("VB描写"), DefaultValue(1.0), Description("直線や円を描く時の線の太さ(0.0以下は代入不可)を入力・取得します。")]
        public double DrawWidth
        {
            get { return this.DrawPen.Width; }

            set
            {
                if (value <= 0.0)
                    return;

                this.DrawPen.Width = value;
            }
        }

        /// <summary>直線や円を描く時の線の上書き手法</summary>
        [Category("VB描写"), DefaultValue(System.NetFramework.CompositingMode.SourceOver), Description("直線や円を描く時の上書き手法をSystem.NetFramework.CompositingMode形式で入力・取得します。")]
        public System.NetFramework.CompositingMode DrawCompositingMode
        {
            get { return this.DrawCMode; }

            set
            {
                this.DrawCMode = value;

                if (this.TargetGraphics != null)
                    this.TargetGraphics.Raster.CompositingMode = value;
            }
        }

        /// <summary>直線や円を描く時の線の品質</summary>
        [Category("VB描写"), DefaultValue(System.NetFramework.SmoothingMode.Default), Description("直線や円を描く時の品質をSystem.NetFramework.SmoothingMode形式で入力・取得します。")]
        public System.NetFramework.SmoothingMode DrawSmoothingMode
        {
            get { return this.DrawSMode; }

            set
            {
                this.DrawSMode = value;

                if (this.TargetGraphics != null)
                    this.TargetGraphics.Raster.SmoothingMode = value;
            }
        }

        /// <summary>直線や円弧・扇を描く時の破線時の形</summary> 
        [Category("VB描写"), DefaultValue(System.Windows.Media.PenLineCap.Flat), Description("直線や円弧・扇を描く時の線の破線時の形をSystem.Windows.Media.PenLineCap形式で入力・取得します。")]
        public System.Windows.Media.PenLineCap DrawDashCap
        {
            get { return this.DrawPen.DashCap; }

            set { this.DrawPen.DashCap = value; }
        }

        /// <summary>直線や円弧・扇を描く時の線の始点の形</summary> 
        [Category("VB描写"), DefaultValue(System.Windows.Media.PenLineCap.Flat), Description("直線や円弧・扇を描く時の線の始点の形をSystem.Windows.Media.PenLineCap形式で入力・取得します。")]
        public System.Windows.Media.PenLineCap DrawStartCap
        {
            get { return this.DrawPen.StartCap; }

            set { this.DrawPen.StartCap = value; }
        }

        /// <summary>直線や円弧・扇を描く時の線の終点の形</summary> 
        [Category("VB描写"), DefaultValue(System.Windows.Media.PenLineCap.Flat), Description("直線や円弧・扇を描く時の線の終点の形をSystem.Windows.Media.PenLineCap形式で入力・取得します。")]
        public System.Windows.Media.PenLineCap DrawEndCap
        {
            get { return this.DrawPen.EndCap; }

            set { this.DrawPen.EndCap = value; }
        }

        /// <summary>直線や円を描く時の線のスタイル int型でしてしても良い(0～4)</summary>
        [Category("VB描写"), DefaultValue(DrawStyleConstants.vbSolid), Description("直線や円を描く時の線のスタイルをDrawStyleConstants形式またはint型(0～4)で入力・取得します。")]
        public DrawStyleConstants DrawStyle
        {
            get
            {
                DrawStyleConstants value = default(DrawStyleConstants);

                switch (this.DrawPen.DashStyle)
                {
                    case System.NetFramework.DashStyle.Solid:
                        value = DrawStyleConstants.vbSolid;
                        break;

                    case System.NetFramework.DashStyle.Dash:
                        value = DrawStyleConstants.vbDash;
                        break;

                    case System.NetFramework.DashStyle.Dot:
                        value = DrawStyleConstants.vbDot;
                        break;

                    case System.NetFramework.DashStyle.DashDot:
                        value = DrawStyleConstants.vbDashDot;
                        break;

                    case System.NetFramework.DashStyle.DashDotDot:
                        value = DrawStyleConstants.vbDashDotDot;
                        break;
                }

                return value;
            }

            set
            {
                switch (value)
                {
                    case DrawStyleConstants.vbSolid:
                        this.DrawPen.DashStyle = System.NetFramework.DashStyle.Solid;
                        break;

                    case DrawStyleConstants.vbDash:
                        this.DrawPen.DashStyle = System.NetFramework.DashStyle.Dash;
                        break;

                    case DrawStyleConstants.vbDot:
                        this.DrawPen.DashStyle = System.NetFramework.DashStyle.Dot;
                        break;

                    case DrawStyleConstants.vbDashDot:
                        this.DrawPen.DashStyle = System.NetFramework.DashStyle.DashDot;
                        break;

                    case DrawStyleConstants.vbDashDotDot:
                        this.DrawPen.DashStyle = System.NetFramework.DashStyle.DashDotDot;
                        break;

                    default:
                        break;
                }
            }
        }

        /// <summary>直線や円を描く時の塗りつぶしの色(ColorConstants形式(ARGB形式))</summary>
        [Category("VB描写"), DefaultValue(ColorConstants.vbBlack), Description("直線(長方形モード時)や円(扇形モード時)を描く時の塗りつぶしの色をColorConstants形式(ARGB形式)で入力・取得します。")]
        public ColorConstants FillColor
        {
            get { return (ColorConstants)this.FillBrush.ForegroundColor.ToArgb(); }

            set
            {
                this.FillBrush = new System.NetFramework.HatchBrush(this.FillBrush.HatchStyle, ((int)value).ToColor(), this.FillBrush.BackgroundColor);
            }
        }

        /// <summary>直線や円を描く時の塗りつぶしのスタイル int型でしてしても良い(0～7)</summary>
        [Category("VB描写"), DefaultValue(FillStyleConstants.vbFSTransparent), Description("直線や円を描く時の塗りつぶしのスタイルをFillStyleConstants形式またはint型(0～7)で入力・取得します。")]
        public FillStyleConstants FillStyle
        {
            get { return this.FStyle; }

            set
            {
                System.NetFramework.HatchStyle tmp = default(System.NetFramework.HatchStyle);

                switch (value)
                {
                    case FillStyleConstants.vbFSSolid:
                        break;

                    case FillStyleConstants.vbFSTransparent:
                        break;

                    case FillStyleConstants.vbHorizontalLine:
                        tmp = System.NetFramework.HatchStyle.Horizontal;
                        break;

                    case FillStyleConstants.vbVerticalLine:
                        tmp = System.NetFramework.HatchStyle.Vertical;
                        break;

                    case FillStyleConstants.vbUpwardDiagonal:
                        tmp = System.NetFramework.HatchStyle.ForwardDiagonal;
                        break;

                    case FillStyleConstants.vbDownwardDiagonal:
                        tmp = System.NetFramework.HatchStyle.BackwardDiagonal;
                        break;

                    case FillStyleConstants.vbCross:
                        tmp = System.NetFramework.HatchStyle.Cross;
                        break;

                    case FillStyleConstants.vbDiagonalCross:
                        tmp = System.NetFramework.HatchStyle.DiagonalCross;
                        break;

                    default:
                        return;
                }

                this.FillBrush = new System.NetFramework.HatchBrush(tmp, this.FillBrush.ForegroundColor, this.FillBrush.BackgroundColor);

                this.FStyle = value;
            }
        }

        /// <summary>イメージ描画に使うラスターオペレーション用のパターンカラー</summary>
        [Category("VB描写"), Description("イメージ描画に使う際のパターンカラーを取得・設定します。")]
        public Color PatternColor
        {
            get { return this.PColor; }

            set
            {
                this.PColor = value;

                if (this.TargetGraphics != null)
                    this.TargetGraphics.Raster.PatternColor = value;
            }
        }
        #endregion

        #region TEXT
        /// <summary>文字を書くときのフォント名</summary>
        [Category("TEXT"), Description("文字を書くときのフォント名を入力・取得します。")]
        public System.Windows.Media.FontFamily FontName
        {
            get { return this.DFont.Family; }

            set { this.DFont.Family = value; }
        }

        /// <summary>文字を書くときのフォントサイズ</summary>
        [Category("TEXT"), DefaultValue(8.25), Description("文字を書くときのフォントサイズを入力・取得します。")]
        public double FontSize
        {
            get { return this.DFont.Size; }

            set { this.DFont.Size = value; }
        }

        /// <summary>文字を書くときのフォントスタイル</summary>
        [Category("TEXT"), DefaultValue("Normal"), Description("文字を書くときのフォントスタイルを入力・取得します。")]
        public System.Windows.FontStyle FontItalic
        {
            get { return this.DFont.Style; }

            set { this.DFont.Style = value; }
        }

        /// <summary>文字を書くときのフォントの太さ</summary>
        [Category("TEXT"), DefaultValue("Normal"), Description("文字を書くときのフォントの太さを入力・取得します。")]
        public System.Windows.FontWeight FontBold
        {
            get { return this.DFont.Weight; }

            set { this.DFont.Weight = value; }
        }

        /// <summary>文字を書くときのフォントオブジェクト</summary>
        [Category("TEXT"), ReadOnly(true), Description("文字を書くときのフォントオブジェクト取得します。")]
        public System.NetFramework.Font Font
        {
            get { return this.DFont; }
        }
        #endregion

        #region その他
        /// <summary>自動的に再描写するかどうか</summary>
        [Category("動作"), DefaultValue(false), Description("自動的に再描写するかどうかを入力・取得します。")]
        public bool AutoRedraw
        {
            get { return this.ARedraw; }

            set { this.ARedraw = value; }
        }

        /// <summary>自動的にイメージをリサイズするかどうか(注：StartingInitの時点での大きさを基にしているので画像が崩れることがある)</summary> 
        [Category("動作"), DefaultValue(false), Description("自動的にイメージをリサイズするかどうかを入力・取得します。(TrueにするとSizeModeがStretchImageになります。)")]
        public bool AutoResize
        {
            get { return base.SizeMode != System.Windows.Media.Stretch.None; }

            set { base.SizeMode = (value == true ? System.Windows.Media.Stretch.Fill : System.Windows.Media.Stretch.None); }
        }

        /// <summary>イメージを取得設定する 代入は前のイメージが破棄される</summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new WriteableBitmap Image
        {
            get { return (WriteableBitmap)this.BaseGraphics.Image; }

            set
            {
                this.ScaleImage = value;
                base.Image = this.ScaleImage;

                if ((this.ScaleImage != null) && (this.TargetGraphics != null))
                    this.TargetGraphics = GetTargetGraphics();

                TryAutoRedraw();
            }
        }

        /// <summary>このインスタンス内でセットしたオブジェクトの数を取得する</summary>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態で実行すると発生</exception>
        [ReadOnly(true)]
        public int ObjectCount
        {
            get
            {
                if (!this.StartEnabled)
                    throw new InvalidOperationException("ObjectCount : Starting_Initしてない状態ではこのプロパティにアクセスできません。");

                return this.TargetGraphics.Vector.ObjectCount;
            }
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを取得、または指定する位置にオブジェクトを挿入する(このPictureBox上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Index">取得、挿入したいオブジェクトのインデックス</param>
        /// <returns>取得したオブジェクト</returns>
        public UIElement this[int Index]
        {
            get { return this.TargetGraphics.Vector[Index]; }
            set { this.TargetGraphics.Vector[Index] = value; }
        }

        /// <summary>オブジェクト編集モジュールを提供します。(インデックスは全て対象とするインデックス)</summary>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態で実行すると発生</exception>
        [ReadOnly(true)]
        public PictureBoxEditVector EditAll
        {
            get
            {
                if (!this.StartEnabled)
                    throw new InvalidOperationException("Edit : Starting_Initしてない状態ではこのプロパティにアクセスできません。");

                return this.EA;
            }
        }

        /// <summary>オブジェクト編集モジュールを提供します。(インデックスは種類別インデックス)</summary>
        /// <remarks>注意
        /// <para>この編集モジュールは編集の際にオブジェクトを検索するので検索無しのタイプに比べて相当コストが掛かります。</para></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態で実行すると発生</exception>
        [ReadOnly(true)]
        public PictureBoxEditVector EditKind
        {
            get
            {
                if (!this.StartEnabled)
                    throw new InvalidOperationException("Edit : Starting_Initしてない状態ではこのプロパティにアクセスできません。");

                return this.EK;
            }
        }

        /// <summary>単位変換モジュールを提供します。</summary>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態で実行すると発生</exception>
        [ReadOnly(true)]
        public PictureBoxUnitConvert Cnv
        {
            get
            {
                if (!this.StartEnabled)
                    throw new InvalidOperationException("Cnv : Starting_Initしてない状態ではこのプロパティにアクセスできません。");

                return this.Converter;
            }
        }

        /// <summary>既にStarting_Initが行われており、すぐ使える状態かどうか(Interruptでの中断では変化しない)</summary>
        [ReadOnly(true)]
        public bool StartEnabled
        {
            get { return this.StartEnabledFlag; }

            private set { this.StartEnabledFlag = value; }
        }

        /// <summary>現在中断されている状態かどうか(初期も中断された状態と判断する)</summary>
        [ReadOnly(true)]
        public bool Interrupting
        {
            get { return this.InterruptFlag; }

            private set { this.InterruptFlag = value; }
        }
        #endregion

        #endregion

        #region 初期化・設定メソッド
        /// <summary>コンストラクタ(基底クラスのPictureBoxも生成)</summary> 
        public PictureBox()
            : base()
        {
            this.StartEnabledFlag = false;
            this.InterruptFlag = true;
            this.TargetGraphics = null;
            this.ScaleImage = null;

            this.FillBrush = new System.NetFramework.HatchBrush(HatchStyle.Horizontal, Colors.Black, base.BackColor);
            this.DrawPen = new System.NetFramework.Pen(Colors.Black, 1.0);
            this.DrawPen.DashCap = System.Windows.Media.PenLineCap.Flat;
            this.DrawPen.StartCap = System.Windows.Media.PenLineCap.Flat;
            this.DrawPen.EndCap = System.Windows.Media.PenLineCap.Flat;
            this.FStyle = FillStyleConstants.vbFSTransparent;
            this.DrawCMode = System.NetFramework.CompositingMode.SourceOver;
            this.DrawSMode = System.NetFramework.SmoothingMode.Default;
            this.DFont = new Font(FontFamilyConstants.Verdana);

            this.SW = 100.0;
            this.SL = 0.0;
            this.SH = 100.0;
            this.ST = 0.0;
            this.SM = ScaleModeConstants.vbPixels;
            this.XAD = AxialDirectionConstants.XAxial.Right;
            this.YAD = AxialDirectionConstants.YAxial.Bottom;

            this.AutoRedraw = false;
            this.AutoResize = false;

            Init_CurrentValue();
        }

        /// <summary>Scale～の設定(vbUserに自動設定、Current～も初期化)</summary> 
        /// <param name="ScaleWidth">仮想座標の幅(マイナスの値の場合はX軸の方向がLeftになる)</param> 
        /// <param name="ScaleHeight">仮想座標の高さ(マイナスの値の場合はY軸の方向がTopになる)</param> 
        /// <param name="ScaleLeft">仮想座標の左端の値</param> 
        /// <param name="ScaleTop">仮想座標の上端の値</param> 
        public void Init_Scale(double ScaleLeft, double ScaleTop, double ScaleWidth, double ScaleHeight)
        {
            this.ScaleWidth = ScaleWidth;
            this.ScaleLeft = ScaleLeft;
            this.ScaleHeight = ScaleHeight;
            this.ScaleTop = ScaleTop;
            this.ScaleMode = ScaleModeConstants.vbUser;

            Init_CurrentValue();
        }

        /// <summary>実際に使うための準備メソッド 描いてあるイメージなどは全て破棄する</summary>
        /// <exception cref="System.InvalidOperationException">PictureBoxのWidthかHightが0だった場合に発生</exception>
        public void Starting_Init()
        {
            if (base.Width == 0.0 || base.Height == 0.0)
                throw new InvalidOperationException("Starting_Init : PictureBoxの幅及び高さが0の時にはこのメソッドは使えません。");

            this.ScaleImage = new WriteableBitmap((int)Math.Ceiling(base.Width), (int)Math.Ceiling(base.Height));
            base.Image = this.ScaleImage;

            this.TargetGraphics = GetTargetGraphics();
            this.StartEnabled = true;
            this.Interrupting = false;
            this.Converter = new PictureBoxUnitConvert(this);
            this.EA = new PictureBoxEditVector(this, this.TargetGraphics.Vector.EditAll);
            this.EK = new PictureBoxEditVector(this, this.TargetGraphics.Vector.EditKind);
        }

        /// <summary>内部の動作を一時停止・再稼働させる(ResizeはそのままRedrawは停止)</summary>
        /// <exception cref="System.InvalidOperationException">Starting_Initをしていない状態で呼び出す場合に発生</exception>
        public void Interrupt()
        {
            if (!this.StartEnabled)
                throw new InvalidOperationException("Interrupt : Starting_Initしてない状態ではこのメソッドは使えません。");

            //再開
            if (this.Interrupting)
                TryAutoRedraw();

            //中断
            else
                this.Interrupting = true;
        }

        /// <summary>外部アクセスの場合に使うメソッド Graphicsオブジェクトを作成して返す</summary>
        /// <param name="DirectAccess">直接アクセスするかどうか 直接アクセスでImageに直接描写する 省略可 その場合Falseになる</param>
        /// <returns>作られたGraphicsオブジェクト</returns>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>注意：これを直接アクセスで使う場合Interruptで一時停止させる必要がある。通常アクセスは基底クラスのCreateGraphicsと同じである。</para>
        /// <para>外部アクセス時にはAutoRedrawは動作しないので内部動作を再開した時のRedrawに任せるか、明示的にPictureBox.Redraw()を呼び出す。</para>
        /// <para>PictureBox.Interrupt()</para>
        /// <para>Dim g As Graphics = PictureBox.CreateGraphics(True)</para>
        /// <para>g.DrawRectangle(Pens.Black,PictureBox.X(-0.5), _</para>
        /// <para>PictureBox.Y(0.5),PictureBox.VX(1),PictureBox.VY(1))</para>
        /// <para>PictureBox.Interrupt()：(この時点でAutoRedrawが再開される。)</para>
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">内部アクセスした場合でかつStarting_InitしていないまたはInterruptで中断されていない場合に発生</exception>
        public System.NetFramework.RVGraphics CreateGraphics([Optional]NullableClass<bool> DirectAccess)
        {
            //直接アクセス
            if (DirectAccess.GetValueOrDefault(false))
            {
                if (this.StartEnabled && !this.Interrupting)
                    throw new InvalidOperationException("CreateGraphics : Starting_InitしておりInterruptで中断している状態以外ではこのメソッドは使えません。");

                return this.TargetGraphics;
            }

            //既定クラスアクセス
            else
                return base.CreateGraphics();
        }

        /// <summary>Current～の値の初期化メソッド</summary>
        private void Init_CurrentValue()
        {
            //幅がマイナスの場合反転させてX軸方向をLeftにする
            if (this.ScaleWidth < 0)
            {
                this.SW = -this.SW;
                this.XAxialDirection = AxialDirectionConstants.XAxial.Left;
            }

            //高さがマイナスの場合反転させてY軸方向をTopにする
            if (this.ScaleHeight < 0)
            {
                this.SH = -this.SH;
                this.YAxialDirection = AxialDirectionConstants.YAxial.Top;
            }

            if (this.ScaleMode == ScaleModeConstants.vbUser)
            {
                this.CurrentX = this.ScaleLeft;
                this.CurrentY = this.ScaleTop;
            }

            else
            {
                this.CurrentX = (this.XAxialDirection == AxialDirectionConstants.XAxial.Right) ? 0 : (this.ScaleImage == null ? base.Width : this.ScaleImage.PixelWidth);
                this.CurrentY = (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom) ? 0 : (this.ScaleImage == null ? base.Height : this.ScaleImage.PixelHeight);
            }
        }

        /// <summary>イメージに対して描画するGraphicsオブジェクトを取得する</summary>
        /// <returns>Graphicsオブジェクト</returns>
        private System.NetFramework.RVGraphics GetTargetGraphics()
        {
            System.NetFramework.RVGraphics g = System.NetFramework.Graphics.FromGraphicsBox(this.BaseGraphics);
            g.Raster.SmoothingMode = this.DrawSmoothingMode;
            g.Raster.CompositingMode = this.DrawCompositingMode;
            g.Raster.PatternColor = this.PatternColor;
            return g;
        }
        #endregion

        #region Redrawメソッド
        /// <summary>AutoRedrawに従って非同期で再描画する</summary> 
        internal void TryAutoRedraw()
        {
            if (!this.AutoRedraw)
                return;
           
            base.Invalidate();
            this.ScaleImage.Invalidate();
        }

        /// <summary>再描写する(基底クラスのCreateGraphicsからアクセスして再描画する場合は非同期で行うと動作がおかしくなる)</summary> 
        /// <param name="NonSynchronize">非同期で再描画するかどうか 省略化 その場合Trueになる</param>
        public void Redraw([Optional]NullableClass<bool> NonSynchronize)
        {
            if (NonSynchronize.GetValueOrDefault(true))
                base.Invalidate();

            else
                base.Refresh();
            
            this.ScaleImage.Invalidate();
        }
        #endregion

        #region 単位変換メソッド

        #region 通常変換
        /// <summary>GetX() : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetX()</para></remarks>
        public double X(double Value)
        {
            return GetX(Value);
        }

        /// <summary>GetY() : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetY()</para></remarks>
        public double Y(double Value)
        {
            return GetY(Value);
        }

        /// <summary>GetArrayX() : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayX()</para></remarks>
        public double[] AX(double[] Value)
        {
            return GetArrayX(Value);
        }

        /// <summary>GetArrayY() : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayY()</para></remarks>
        public double[] AY(double[] Value)
        {
            return GetArrayY(Value);
        }

        /// <summary>GetValueX() : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueX()</para></remarks>
        public double VX(double Value)
        {
            return GetValueX(Value);
        }

        /// <summary>GetValueY() : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueY()</para></remarks>
        public double VY(double Value)
        {
            return GetValueY(Value);
        }

        /// <summary>GetValueArrayX() : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayX()</para></remarks>
        public double[] VAX(double[] Value)
        {
            return GetValueArrayX(Value);
        }

        /// <summary>GetValueArrayY() : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayY()</para></remarks>
        public double[] VAY(double[] Value)
        {
            return GetValueArrayY(Value);
        }

        /// <summary>GetPoint() : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        /// <remarks>内部アクセス名<para>GetPoint()</para></remarks>
        public Point P(Point Value)
        {
            return GetPoint(Value);
        }

        /// <summary>GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetArrayPoint()</para></remarks>
        public Point[] AP(Point[] Value)
        {
            return GetArrayPoint(Value);
        }

        /// <summary>GetValueSize() : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetValueSize()</para></remarks>
        public Size VS(Size Value)
        {
            return GetValueSize(Value);
        }

        /// <summary>GetValueArraySize() : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArraySize()</para></remarks>
        public Size[] VAS(Size[] Value)
        {
            return GetValueArraySize(Value);
        }
        #endregion

        #region 逆変換
        /// <summary>GetReverseX() : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseX()</para></remarks>
        public double RX(double Value)
        {
            return GetReverseX(Value);
        }

        /// <summary>GetReverseY() : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseY()</para></remarks>
        public double RY(double Value)
        {
            return GetReverseY(Value);
        }

        /// <summary>GetReverseArrayX() : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayX()</para></remarks>
        public double[] RAX(double[] Value)
        {
            return GetReverseArrayX(Value);
        }

        /// <summary>GetReverseArrayY() : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayY()</para></remarks>
        public double[] RAY(double[] Value)
        {
            return GetReverseArrayY(Value);
        }

        /// <summary>GetReverseValueX() : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueX()</para></remarks>
        public double RVX(double Value)
        {
            return GetReverseValueX(Value);
        }

        /// <summary>GetReverseValueY() : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueY()</para></remarks>
        public double RVY(double Value)
        {
            return GetReverseValueY(Value);
        }

        /// <summary>GetReverseValueArrayX() : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayX()</para></remarks>
        public double[] RVAX(double[] Value)
        {
            return GetReverseValueArrayX(Value);
        }

        /// <summary>GetReverseValueArrayY() : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayY()</para></remarks>
        public double[] RVAY(double[] Value)
        {
            return GetReverseValueArrayY(Value);
        }

        /// <summary>GetReversePoint() : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        /// <remarks>内部アクセス名<para>GetReversePoint()</para></remarks>
        public Point RP(Point Value)
        {
            return GetReversePoint(Value);
        }

        /// <summary>GetReverseArrayPoint() : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayPoint()</para></remarks>
        public Point[] RAP(Point[] Value)
        {
            return GetReverseArrayPoint(Value);
        }

        /// <summary>GetReverseValueSize() : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueSize()</para></remarks>
        public Size RVS(Size Value)
        {
            return GetReverseValueSize(Value);
        }

        /// <summary>GetReverseValueArraySize() : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArraySize()</para></remarks>
        public Size[] RVAS(Size[] Value)
        {
            return GetReverseValueArraySize(Value);
        }
        #endregion

        #region その他の変換
        /// <summary>GetStepX() : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepX()</para></remarks>
        public double SX(double Value)
        {
            return GetStepX(Value);
        }

        /// <summary>GetStepY() : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepY()</para></remarks>
        public double SY(double Value)
        {
            return GetStepY(Value);
        }

        /// <summary>GetStepArrayX() : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayX()</para></remarks>
        public double[] SAX(double[] Value)
        {
            return GetStepArrayX(Value);
        }

        /// <summary>GetStepArrayY() : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayY()</para></remarks>
        public double[] SAY(double[] Value)
        {
            return GetStepArrayY(Value);
        }

        /// <summary>GetStepPoint() : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        /// <remarks>内部アクセス名<para>GetStepPoint()</para></remarks>
        public Point SP(Point Value)
        {
            return GetStepPoint(Value);
        }

        /// <summary>GetStepArrayPoint() : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayPoint()</para></remarks>
        public Point[] SAP(Point[] Value)
        {
            return GetStepArrayPoint(Value);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public double[] PA(double[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Point[] PA(Point[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Size[] PA(Size[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public double[] PA(double[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Point[] PA(Point[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Size[] PA(Size[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #region メソッドの中身の記述

        #region 内部通常変換
        internal double GetX(double X)
        {
            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    X = X - (this.XAxialDirection == AxialDirectionConstants.XAxial.Right ? this.ScaleLeft : this.ScaleLeft - this.ScaleWidth);
                    X = X * (this.ScaleImage.PixelWidth / this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    X = GetValueX(X);
                    break;
            }

            if (this.XAxialDirection == AxialDirectionConstants.XAxial.Left)
                X = this.ScaleImage.PixelWidth - X;

            return X;
        }

        internal double GetValueX(double VX)
        {
            double dpi = 96.0;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VX = VX * (this.ScaleImage.PixelWidth / this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                    VX = (VX / 1440.0) * dpi;
                    break;

                case ScaleModeConstants.vbPoints:
                    VX = (VX / 72.0) * dpi;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VX = ((VX * 120.0) / 1440.0) * dpi;
                    break;

                case ScaleModeConstants.vbInches:
                    VX = VX * dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VX = (VX / 25.4) * dpi;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VX = (VX / 2.54) * dpi;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VX = (VX / 2540.0) * dpi;
                    break;
            }

            return VX;
        }

        internal double[] GetArrayX(double[] X)
        {
            double[] TX = new double[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetX(X[i]);

            return TX;
        }

        internal double[] GetValueArrayX(double[] VX)
        {
            double[] TX = new double[VX.Length];

            for (int i = 0; i < VX.Length; i++)
                TX[i] = GetValueX(VX[i]);

            return TX;
        }

        internal double GetY(double Y)
        {
            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    Y = Y - (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom ? this.ScaleTop : this.ScaleTop - this.ScaleHeight);
                    Y = Y * (this.ScaleImage.PixelHeight / this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    Y = GetValueY(Y);
                    break;
            }

            if (this.YAxialDirection == AxialDirectionConstants.YAxial.Top)
                Y = this.ScaleImage.PixelHeight - Y;

            return Y;
        }

        internal double GetValueY(double VY)
        {
            double dpi = 96.0;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VY = VY * (this.ScaleImage.PixelHeight / this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                    VY = (VY / 1440.0) * dpi;
                    break;

                case ScaleModeConstants.vbPoints:
                    VY = (VY / 72.0) * dpi;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VY = ((VY * 120.0) / 1440.0) * dpi;
                    break;

                case ScaleModeConstants.vbInches:
                    VY = VY * dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VY = (VY / 25.4) * dpi;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VY = (VY / 2.54) * dpi;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VY = (VY / 2540.0) * dpi;
                    break;
            }

            return VY;
        }

        internal double[] GetArrayY(double[] Y)
        {
            double[] TY = new double[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetY(Y[i]);

            return TY;
        }

        internal double[] GetValueArrayY(double[] VY)
        {
            double[] TY = new double[VY.Length];

            for (int i = 0; i < VY.Length; i++)
                TY[i] = GetValueY(VY[i]);

            return TY;
        }

        internal Point GetPoint(Point P)
        {
            P.X = GetX(P.X);
            P.Y = GetY(P.Y);

            return P;
        }

        internal Point[] GetArrayPoint(Point[] P)
        {
            Point[] TP = new Point[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetX(P[i].X);
                TP[i].Y = GetY(P[i].Y);
            }

            return TP;
        }

        internal Size GetValueSize(Size S)
        {
            S.Width = GetValueX(S.Width);
            S.Height = GetValueY(S.Height);

            return S;
        }

        internal Size[] GetValueArraySize(Size[] S)
        {
            Size[] TS = new Size[S.Length];

            for (int i = 0; i < S.Length; i++)
            {
                TS[i].Width = GetValueX(S[i].Width);
                TS[i].Height = GetValueY(S[i].Height);
            }

            return TS;
        }
        #endregion

        #region 内部逆変換
        internal double GetReverseX(double X)
        {
            if (this.XAxialDirection == AxialDirectionConstants.XAxial.Left)
                X = this.ScaleImage.PixelWidth - X;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    X = X * (this.ScaleWidth / this.ScaleImage.PixelWidth);
                    X = X + (this.XAxialDirection == AxialDirectionConstants.XAxial.Right ? this.ScaleLeft : this.ScaleLeft - this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    X = GetReverseValueX(X);
                    break;
            }

            return X;
        }

        internal double GetReverseValueX(double VX)
        {
            double dpi = 96.0;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VX = VX * (this.ScaleWidth / this.ScaleImage.PixelWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                    VX = (VX / dpi) * 1440.0;
                    break;

                case ScaleModeConstants.vbPoints:
                    VX = (VX / dpi) * 72.0;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VX = (VX * dpi) * 1440.0 / 120.0;
                    break;

                case ScaleModeConstants.vbInches:
                    VX = VX / dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VX = (VX / dpi) * 25.4;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VX = (VX / dpi) * 2.54;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VX = (VX / dpi) * 2540.0;
                    break;
            }

            return VX;
        }

        internal double[] GetReverseArrayX(double[] X)
        {
            double[] TX = new double[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetReverseX(X[i]);

            return TX;
        }

        internal double[] GetReverseValueArrayX(double[] VX)
        {
            double[] TX = new double[VX.Length];

            for (int i = 0; i < VX.Length; i++)
                TX[i] = GetReverseValueX(VX[i]);

            return TX;
        }

        internal double GetReverseY(double Y)
        {
            if (this.YAxialDirection == AxialDirectionConstants.YAxial.Top)
                Y = this.ScaleImage.PixelHeight - Y;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    Y = Y * (this.ScaleHeight / this.ScaleImage.PixelHeight);
                    Y = Y + (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom ? this.ScaleTop : this.ScaleTop - this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    Y = GetReverseValueY(Y);
                    break;
            }

            return Y;
        }

        internal double GetReverseValueY(double VY)
        {
            double dpi = 96.0;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VY = VY * (this.ScaleHeight / this.ScaleImage.PixelHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                    VY = (VY / dpi) * 1440.0;
                    break;

                case ScaleModeConstants.vbPoints:
                    VY = (VY / dpi) * 72.0;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VY = (VY * dpi) * 1440.0 / 120.0;
                    break;

                case ScaleModeConstants.vbInches:
                    VY = VY / dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VY = (VY / dpi) * 25.4;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VY = (VY / dpi) * 2.54;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VY = (VY / dpi) * 2540.0;
                    break;
            }

            return VY;
        }

        internal double[] GetReverseArrayY(double[] Y)
        {
            double[] TY = new double[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetReverseY(Y[i]);

            return TY;
        }

        internal double[] GetReverseValueArrayY(double[] VY)
        {
            double[] TY = new double[VY.Length];

            for (int i = 0; i < VY.Length; i++)
                TY[i] = GetReverseValueY(VY[i]);

            return TY;
        }

        internal Point GetReversePoint(Point P)
        {
            P.X = GetReverseX(P.X);
            P.Y = GetReverseY(P.Y);

            return P;
        }

        internal Point[] GetReverseArrayPoint(Point[] P)
        {
            Point[] TP = new Point[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetReverseX(P[i].X);
                TP[i].Y = GetReverseY(P[i].Y);
            }

            return TP;
        }

        internal Size GetReverseValueSize(Size S)
        {
            S.Width = GetReverseValueX(S.Width);
            S.Height = GetReverseValueY(S.Height);

            return S;
        }

        internal Size[] GetReverseValueArraySize(Size[] S)
        {
            Size[] TS = new Size[S.Length];

            for (int i = 0; i < S.Length; i++)
            {
                TS[i].Width = GetReverseValueX(S[i].Width);
                TS[i].Height = GetReverseValueY(S[i].Height);
            }

            return TS;
        }
        #endregion

        #region 内部その他の変換
        internal double GetStepX(double X)
        {
            return this.CurrentX + X;
        }

        internal double GetStepY(double Y)
        {
            return this.CurrentY + Y;
        }

        internal double[] GetStepArrayX(double[] X)
        {
            double[] TX = new double[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetStepX(X[i]);

            return TX;
        }

        internal double[] GetStepArrayY(double[] Y)
        {
            double[] TY = new double[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetStepY(Y[i]);

            return TY;
        }

        internal Point GetStepPoint(Point P)
        {
            P.X = GetStepX(P.X);
            P.Y = GetStepY(P.Y);

            return P;
        }

        internal Point[] GetStepArrayPoint(Point[] P)
        {
            Point[] TP = new Point[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetStepX(P[i].X);
                TP[i].Y = GetStepY(P[i].Y);
            }

            return TP;
        }

        internal double[] GetPartialArray(double[] Value, int StartIndex, int EndIndex)
        {
            double[] TValue = new double[EndIndex - StartIndex + 1];

            Buffer.BlockCopy(Value, StartIndex * 8, TValue, 0, TValue.Length * 8);

            return TValue;
        }

        internal Point[] GetPartialArray(Point[] Value, int StartIndex, int EndIndex)
        {
            Point[] TValue = new Point[EndIndex - StartIndex + 1];

            Array.Copy(Value, StartIndex, TValue, 0, TValue.Length);

            return TValue;
        }

        internal Size[] GetPartialArray(Size[] Value, int StartIndex, int EndIndex)
        {
            Size[] TValue = new Size[EndIndex - StartIndex + 1];

            Array.Copy(Value, StartIndex, TValue, 0, TValue.Length);

            return TValue;
        }
        #endregion

        #endregion

        #endregion

        #region 提供メソッド(VB6.0に則っている)

        #region 図形描画
        /// <summary>直線を描く</summary> 
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X 省略可 その場合始点Xの方を終点として扱う</param>
        /// <param name="Y2">終点Y 省略可 その場合始点Yの方を終点として扱う</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="LineStyle">直線のスタイル 省略可 その場合Lineとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.Line(X,Y) VB6.0のline -(X,Y)と同等</para> 
        /// <para>PictureBox.Line(X1,Y1,X2,Y2) VB6.0のline (X1,Y1) - (X2,Y2)と同等</para> 
        /// <para>PictureBox.Line(X1,Y1,X2,Y2,Information.QBColor(2),GraphicsStyle.LineStyle.BF) VB6.0のline (X1,Y1) - (X2,Y2),QBColor(2),BFと同等</para> 
        /// </example></remarks> 
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">X2とY2を同時に指定しなかった場合に発生</exception>
        public void Line(double X1, double Y1, [Optional]NullableClass<double> X2, [Optional]NullableClass<double> Y2, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<GraphicsStyle.LineStyle> LineStyle)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("Line : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!X2.HasValue() ^ !Y2.HasValue())
                throw new ArgumentException("Line : X2とY2の値は同時に指定してください。", "X2 , Y2");

            //X2,Y2が省略された場合Current～を始点X1,Y1を終点とする
            if (!X2.HasValue())
            {
                X2 = X1;
                X1 = this.CurrentX;
                Y2 = Y1;
                Y1 = this.CurrentY;
            }

            if (!LineStyle.HasValue())
                LineStyle = GraphicsStyle.LineStyle.Line;

            Pen DrawPen = (DrawColor.HasValue() ? (System.NetFramework.Pen)this.DrawPen.Clone() : this.DrawPen);

            if (DrawColor.HasValue())
                DrawPen.Color = ((int)DrawColor.Value).ToColor();

            //Line
            if (LineStyle == GraphicsStyle.LineStyle.Line)
            {
                Point P1, P2;

                P1 = new Point(GetX(X1), GetY(Y1));
                P2 = new Point(GetX(X2.Value), GetY(Y2.Value));

                this.TargetGraphics.Raster.DrawLine(DrawPen, P1, P2);
            }

            else
            {
                Rect rect;
                double W, H, T, L;

                L = GetX(X1) < GetX(X2.Value) ? GetX(X1) : GetX(X2.Value);
                W = GetX(X1) < GetX(X2.Value) ? GetX(X2.Value) - GetX(X1) : GetX(X1) - GetX(X2.Value);
                T = GetY(Y1) < GetY(Y2.Value) ? GetY(Y1) : GetY(Y2.Value);
                H = GetY(Y1) < GetY(Y2.Value) ? GetY(Y2.Value) - GetY(Y1) : GetY(Y1) - GetY(Y2.Value);

                rect = new Rect(L, T, W, H);

                //FillRectangle
                if (LineStyle == GraphicsStyle.LineStyle.FillRectangle)
                {
                    SolidColorBrush tb = new SolidColorBrush(DrawPen.Color);
                    this.TargetGraphics.Raster.FillRectangle(tb, rect);
                }

                //Rectangle
                else
                {
                    if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                    {
                        if (this.FillStyle == FillStyleConstants.vbFSSolid)
                        {
                            SolidColorBrush tb = new SolidColorBrush(this.FillBrush.ForegroundColor);
                            this.TargetGraphics.Raster.FillRectangle(tb, rect);
                        }

                        else
                            this.TargetGraphics.Raster.FillRectangle(this.FillBrush, rect);
                    }

                    this.TargetGraphics.Raster.DrawRectangle(DrawPen, rect.X, rect.Y, rect.Width, rect.Height);
                }
            }

            this.CurrentX  = X2.Value;
            this.CurrentY  = Y2.Value;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;

            TryAutoRedraw();
        }

        /// <summary>直線をセットする</summary> 
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X 省略可 その場合始点Xの方を終点として扱う</param>
        /// <param name="Y2">終点Y 省略可 その場合始点Yの方を終点として扱う</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="LineStyle">直線のスタイル 省略可 その場合Lineとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.ObjectLine(X,Y) VB6.0のline -(X,Y)と同等</para> 
        /// <para>PictureBox.ObjectLine(X1,Y1,X2,Y2) VB6.0のline (X1,Y1) - (X2,Y2)と同等</para> 
        /// <para>PictureBox.ObjectLine(X1,Y1,X2,Y2,Information.QBColor(2),GraphicsStyle.LineStyle.BF) VB6.0のline (X1,Y1) - (X2,Y2),QBColor(2),BFと同等</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">X2とY2を同時に指定しなかった場合に発生</exception>
        public void ObjectLine(double X1, double Y1, [Optional]NullableClass<double> X2, [Optional]NullableClass<double> Y2, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<GraphicsStyle.LineStyle> LineStyle)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("ObjectLine : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!X2.HasValue() ^ !Y2.HasValue())
                throw new ArgumentException("ObjectLine : X2とY2の値は同時に指定してください。", "X2 , Y2");

            //X2,Y2が省略された場合Current～を始点X1,Y1を終点とする
            if (!X2.HasValue())
            {
                X2 = X1;
                X1 = this.CurrentX;
                Y2 = Y1;
                Y1 = this.CurrentY;
            }

            if (!LineStyle.HasValue())
                LineStyle = GraphicsStyle.LineStyle.Line;

            Pen DrawPen = (DrawColor.HasValue() ? (System.NetFramework.Pen)this.DrawPen.Clone() : this.DrawPen);

            if (DrawColor.HasValue())
                DrawPen.Color = ((int)DrawColor.Value).ToColor();

            //Line
            if (LineStyle == GraphicsStyle.LineStyle.Line)
            {
                Point P1, P2;

                P1 = new Point(GetX(X1), GetY(Y1));
                P2 = new Point(GetX(X2.Value), GetY(Y2.Value));

                this.TargetGraphics.Vector.SetLine(DrawPen, P1, P2);
            }

            else
            {
                Rect rect;
                double W, H, T, L;

                L = GetX(X1) < GetX(X2.Value) ? GetX(X1) : GetX(X2.Value);
                W = GetX(X1) < GetX(X2.Value) ? GetX(X2.Value) - GetX(X1) : GetX(X1) - GetX(X2.Value);
                T = GetY(Y1) < GetY(Y2.Value) ? GetY(Y1) : GetY(Y2.Value);
                H = GetY(Y1) < GetY(Y2.Value) ? GetY(Y2.Value) - GetY(Y1) : GetY(Y1) - GetY(Y2.Value);

                rect = new Rect(L, T, W, H);

                //FillRectangle
                if (LineStyle == GraphicsStyle.LineStyle.FillRectangle)
                {
                    Brush tb = new SolidColorBrush(DrawPen.Color);
                    this.TargetGraphics.Vector.SetFillRectangle(tb, rect);
                }

                //Rectangle
                else
                {
                    if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                        this.TargetGraphics.Vector.SetFillRectangle((SolidColorBrush)this.FillBrush, rect);

                    else
                        this.TargetGraphics.Vector.SetFillRectangle(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)), rect);

                    Rectangle rectangle = (Rectangle)this.TargetGraphics.Vector.GetObject(this.TargetGraphics.Vector.ObjectCount - 1);

                    this.TargetGraphics.Vector.EditAll.Rectangle(rectangle, DrawPen);
                }
            }

            this.CurrentX  = X2.Value;
            this.CurrentY  = Y2.Value;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;
        }

        /// <summary>点を描く</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param> 
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.PSet(X,Y) VB6.0のPSet (X,Y)と同等</para> 
        /// <para>PictureBox.PSet(X,Y,Information.QBColor(3)) VB6.0のPSet (X,Y),QBColor(3)と同等</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        public void PSet(double X, double Y, [Optional]NullableClass<ColorConstants> DrawColor)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("PSet : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            Color tcolor;

            if (!DrawColor.HasValue())
                DrawColor = (ColorConstants)this.DrawPen.Color.ToArgb();

            tcolor = ((int)DrawColor.Value).ToColor();

            this.TargetGraphics.Raster.FillEllipse(new SolidColorBrush(tcolor), GetX(X) - 1.5, GetY(Y) - 1.5, 3.0, 3.0);

            this.CurrentX  = X;
            this.CurrentY  = Y;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;

            TryAutoRedraw();
        }

        /// <summary>点をセットする</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param> 
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.ObjectPSet(X,Y) VB6.0のPSet (X,Y)と同等</para> 
        /// <para>PictureBox.ObjectPSet(X,Y,Information.QBColor(3)) VB6.0のPSet (X,Y),QBColor(3)と同等</para> 
        /// </example></remarks> 
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        public void ObjectPSet(double X, double Y, [Optional]NullableClass<ColorConstants> DrawColor)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("ObjectPSet : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!DrawColor.HasValue())
                DrawColor = (ColorConstants)this.DrawPen.Color.ToArgb();

            System.Windows.Media.SolidColorBrush tb = new SolidColorBrush(((int)DrawColor.Value).ToColor());

            this.TargetGraphics.Vector.SetFillEllipse(tb, GetX(X) - 1.5, GetY(Y) - 1.5, 3.0, 3.0);

            this.CurrentX  = X;
            this.CurrentY  = Y;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;
        }

        /// <summary>円を描く(角度指定はStartRadから開始のEndRadで終了で角度とその方向を決めるプラスが左回り)</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="R">半径を指定 0.0より大きい値(X軸の単位)</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="StartRad">開始角度(ラジアン) 省略可 その場合0となる</param>
        /// <param name="EndRad">終了角度(ラジアン) 省略可 その場合2πとなる</param> 
        /// <param name="Aspect">アスペクト比(縦/横) 省略可 その場合1となる</param>
        /// <param name="CircleStyle">円のスタイル(VB6.0での円弧・扇形の指定はここで) 省略可 その場合Arcとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBox.Circle(X,Y,R) VB6.0のCircle (X,Y),Rと同等</para> 
        /// <para>PictureBox.Circle(X,Y,R,C, , ,ASP) VB6.0のCircle (X,Y),R,C, , ,ASPと同等(C:色 ASP:アスペクト比)</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Rの値が0以下になっている場合に発生</exception>
        public void Circle(double X, double Y, double R, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<double> StartRad, [Optional]NullableClass<double> EndRad, [Optional]NullableClass<double> Aspect, [Optional]NullableClass<GraphicsStyle.CircleStyle> CircleStyle)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("Crcle ： Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (R <= 0.0f)
                throw new ArgumentOutOfRangeException("R", "Crcle ： Rの値は0.0より大きい値で指定してください。");

            if (!StartRad.HasValue())
                StartRad = 0.0;

            if (!EndRad.HasValue())
                EndRad = 2.0 * Math.PI;

            if (!Aspect.HasValue())
                Aspect = 1.0;

            if (!CircleStyle.HasValue())
                CircleStyle = GraphicsStyle.CircleStyle.Arc;

            double SHX, SHY;
            Pen DrawPen = (!DrawColor.HasValue() ? this.DrawPen : (System.NetFramework.Pen)this.DrawPen.Clone());

            if (DrawColor.HasValue())
                DrawPen.Color = ((int)DrawColor.Value).ToColor();

            //アスペクト比に従ってXの半径とYの半径を決める
            SHX = GetValueX(Aspect < 1.0 ? R / Aspect.Value : R);
            SHY = GetValueX(Aspect > 1.0 ? R * Aspect.Value : R);

            //StartRadとEndRadの差が2π未満ならば
            if (Math.Abs(EndRad.Value - StartRad.Value) < 2.0 * Math.PI)
            {
                bool flag = false;

                //StartRadがマイナスならばプラスにする
                while (StartRad < 0.0)
                    StartRad += 2.0 * Math.PI;

                //EndRadがマイナスならばプラスにしてflag=trueにする
                while (EndRad < 0.0)
                {
                    EndRad += 2.0 * Math.PI;
                    flag = true;
                }

                //最終的に使うのは始点と角度なので角度を計算する
                EndRad = EndRad.Value - StartRad.Value;

                if (EndRad < 0.0 && flag == false)
                    EndRad += 2.0 * Math.PI;

                else if (EndRad > 0.0 && flag == true)
                    EndRad -= 2.0 * Math.PI;

                //.NET用の回転方向と度数単位に合わせる
                StartRad = -StartRad.Value * 180.0 / Math.PI;
                EndRad = -EndRad.Value * 180.0 / Math.PI;
            }

            //StartRadとEndRadの差が2π以上ならば
            else
            {
                StartRad = 0.0;
                EndRad = 360.0;
            }

            //Arc
            if (CircleStyle == GraphicsStyle.CircleStyle.Arc)
                this.TargetGraphics.Raster.DrawArc(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0, StartRad.Value, EndRad.Value);

            //FillPie
            else if (CircleStyle == GraphicsStyle.CircleStyle.FillPie)
                this.TargetGraphics.Raster.FillPie(new SolidColorBrush(DrawPen.Color), GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0, StartRad.Value, EndRad.Value);

            //Pie
            else
            {
                if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                {
                    if (this.FillStyle == FillStyleConstants.vbFSSolid)
                        this.TargetGraphics.Raster.FillPie(new SolidColorBrush(this.FillBrush.ForegroundColor), GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0, StartRad.Value, EndRad.Value);

                    else
                        this.TargetGraphics.Raster.FillPie(this.FillBrush, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0, StartRad.Value, EndRad.Value);
                }

                if (Math.Abs(EndRad.Value) >= 360.0)
                    this.TargetGraphics.Raster.DrawEllipse(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0);

                else
                    this.TargetGraphics.Raster.DrawPie(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0, StartRad.Value, EndRad.Value);
            }

            this.CurrentX  = X;
            this.CurrentY  = Y;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;

            TryAutoRedraw();
        }

        /// <summary>円をセットする</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="R">半径を指定 0.0より大きい値(X軸の単位)</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="Aspect">アスペクト比(縦/横) 省略可 その場合1となる</param>
        /// <param name="CircleStyle">円のスタイル(VB6.0での円弧・扇形の指定はここで) 省略可 その場合Arcとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBox.ObjectCircle(X,Y,R) VB6.0のCircle (X,Y),Rと同等</para> 
        /// <para>PictureBox.ObjectCircle(X,Y,R,C, , ,ASP) VB6.0のCircle (X,Y),R,C, , ,ASPと同等(C:色 ASP:アスペクト比)</para> 
        /// </example></remarks> 
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Rの値が0以下になっている場合に発生</exception>
        public void ObjectCircle(double X, double Y, double R, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<double> Aspect, [Optional]NullableClass<GraphicsStyle.ObjectCircleStyle> CircleStyle)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("ObjectCircle ： Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (R <= 0.0)
                throw new ArgumentOutOfRangeException("R", "ObjectCircle ： Rの値は0.0より大きい値で指定してください。");

            if (!Aspect.HasValue())
                Aspect = 1.0;

            if (!CircleStyle.HasValue())
                CircleStyle = GraphicsStyle.ObjectCircleStyle.Circle;

            double SHX, SHY;
            Pen DrawPen = (!DrawColor.HasValue() ? this.DrawPen : (System.NetFramework.Pen)this.DrawPen.Clone());

            if (DrawColor.HasValue())
                DrawPen.Color = ((int)DrawColor.Value).ToColor();

            //アスペクト比に従ってXの半径とYの半径を決める
            SHX = GetValueX(Aspect < 1.0 ? R / Aspect.Value : R);
            SHY = GetValueX(Aspect > 1.0 ? R * Aspect.Value : R);

            //FillCircle
            if (CircleStyle == GraphicsStyle.ObjectCircleStyle.FillCircle)
                this.TargetGraphics.Vector.SetFillEllipse(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0);

            //Circle
            else
            {
                if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                    this.TargetGraphics.Vector.SetFillEllipse((SolidColorBrush)this.FillBrush, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0);

                else
                    this.TargetGraphics.Vector.SetFillEllipse(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)), GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0, SHY * 2.0);

                Ellipse ellipse = (Ellipse)this.TargetGraphics.Vector.GetObject(this.TargetGraphics.Vector.ObjectCount - 1);

                this.TargetGraphics.Vector.EditAll.Ellipse(ellipse, DrawPen);
            }

            this.CurrentX  = X;
            this.CurrentY  = Y;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;
        }
        #endregion

        #region テキスト・画像描画
        /// <summary>文字列をセットする(フォントはプロパティDrawFont、フォントカラーはプロパティDrawColorまたは指定した色に依存)</summary>
        /// <param name="DrawString">セットしたい文字列</param>
        /// <param name="X">文字列の左上端座標のX 省略可 その場合CurrentXの値を使用</param>
        /// <param name="Y">文字列の左上端座標のY 省略可 その場合CurrentYの値を使用</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBox.ObjectPrint("ABC") VB6.0のPrint "ABC"同等(Curent～で予めX,Yを決めておく)</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">XとYの値を同時に指定しないで呼び出した場合に発生</exception>
        public void ObjectPrint(string DrawString, [Optional]NullableClass<double> X, [Optional]NullableClass<double> Y, [Optional]NullableClass<ColorConstants> DrawColor)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("ObjectPrint : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!X.HasValue() ^ !Y.HasValue())
                throw new ArgumentException("ObjectPrint : XとYの値は同時に指定してください。", "X , Y");

            //X,Yが与えられなかった場合Current～を使う
            if (!X.HasValue())
            {
                X = this.CurrentX;
                Y = this.CurrentY;
            }

            Color tc = (DrawColor.HasValue() ? ((int)DrawColor.Value).ToColor() : this.DrawPen.Color);

            Brush tb = new SolidColorBrush(tc);
            this.TargetGraphics.Vector.SetString(DrawString, this.Font, tb, GetX(X.Value), GetY(Y.Value));

            this.CurrentX = X.Value;
            this.CurrentY = Y.Value;

            if (DrawColor.HasValue())
                this.ForeColor = DrawColor.Value;
        }

        /// <summary>イメージを描画する<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="Source">描画するイメージ</param>
        /// <param name="X">描画したい場所の左上端座標X(ScaleMode単位)</param>
        /// <param name="Y">描画したい場所の左上端座標Y(ScaleMode単位)</param>
        /// <param name="Width">描画したい場所範囲の幅(ScaleMode単位) 省略可</param>
        /// <param name="Height">描画したい場所範囲の高さ(ScaleMode単位) 省略可</param>
        /// <param name="SrcX">描画したいイメージの部分範囲の左上端座標X(ピクセル単位) 省略可</param>
        /// <param name="SrcY">描画したいイメージの部分範囲の左上端座標Y(ピクセル単位) 省略可</param>
        /// <param name="SrcWidth">描画したいイメージの部分範囲の幅(ピクセル単位) マイナスの値で反転可 省略可</param>
        /// <param name="SrcHeight">描画したいイメージの部分範囲の高さ(ピクセル単位) マイナスの値で反転可 省略可</param>
        /// <param name="RasterOP">ラスターオペレーション 省略可 その場合vbSrcAlphaとなる</param>
        /// <param name="SourceAlpha">描画したいイメージの不透明度(0.0～1.0) 省略化 その場合1.0となる</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.PaintPicture(img,X,Y) VB6.0のPaintPicture img,X,Yと同等</para>
        /// <para>PictureBox.PaintPicture(img,X1,Y1,W1,H1,X2,Y2,W2,H2) VB6.0のPaintPicture img,X1,Y1,W1,H1,X2,Y2,W2,H2と同等</para>
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">SourceAlphaの値が0.0～1.0の範囲ではない場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthかHeightに0以下を指定した場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">SrcWidthかSrcHeightに0を指定した場合に発生</exception>
        /// <exception cref="System.ArgumentException">WidthとHeight、SrcWidthとSrcHeight、SrcXとSrcYを指定したときに同時に指定しなかった場合に発生</exception>
        public void PaintPicture(System.NetFramework.CustomWriteableBitmap Source, double X, double Y, [Optional]NullableClass<double> Width, [Optional]NullableClass<double> Height, [Optional]NullableClass<int> SrcX, [Optional]NullableClass<int> SrcY, [Optional]NullableClass<int> SrcWidth, [Optional]NullableClass<int> SrcHeight, [Optional]NullableClass<RasterOpConstants> RasterOP, [Optional]NullableClass<double> SourceAlpha)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("PaintPicture : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!SourceAlpha.HasValue())
                SourceAlpha = 1.0;

            if (0.0 > SourceAlpha || SourceAlpha > 1.0)
                throw new ArgumentOutOfRangeException("SourceAlpha", "PaintPicture : SourceAlphaの値は0.0～1.0の間です。");

            if ((!Width.HasValue() ^ !Height.HasValue()) || (!SrcWidth.HasValue() ^ !SrcHeight.HasValue()))
                throw new ArgumentException("PaintPicture : WidthとHeightやSrcWidthとSrcHeightの値は同時に指定してください。", "Width , Height or SrcWidth , SrcHeight");

            else if (!SrcX.HasValue() ^ !SrcY.HasValue())
                throw new ArgumentException("PaintPicture : SrcXとSrcYの値は同時に指定してください。", "SrcX , SrcY");

            Width = (Width.HasValue() ? GetValueX(Width.Value) : this.ScaleImage.PixelWidth);
            Height = (Height.HasValue() ? GetValueY(Height.Value) : this.ScaleImage.PixelHeight);

            SrcX = (SrcX.HasValue() ? SrcX.Value : 0);
            SrcY = (SrcY.HasValue() ? SrcY.Value : 0);
            SrcWidth = (SrcWidth.HasValue() ? SrcWidth.Value : Source.PixelWidth);
            SrcHeight = (SrcHeight.HasValue() ? SrcHeight.Value : Source.PixelHeight);

            if (Width <= 0.0 || Height <= 0.0)
                throw new ArgumentOutOfRangeException("Width , Height", "PaintPicture : WidthとHeightはプラスの値で表記してください。");

            else if (SrcWidth == 0 || SrcHeight == 0)
                throw new ArgumentOutOfRangeException("SrcWidth , SrcHeight", "PaintPicture : SrcWidthとSrcHeightに0は指定できません。");

            if (!RasterOP.HasValue())
                RasterOP = RasterOpConstants.vbSrcAlpha;

            this.TargetGraphics.Raster.DrawImage(Source, new Rect(GetX(X), GetY(Y), Width.Value, Height.Value), new iRect(SrcX.Value, SrcY.Value, SrcWidth.Value, SrcHeight.Value), (RasterOperation)RasterOP.Value, SourceAlpha.Value);

            this.CurrentX = X;
            this.CurrentY = Y;
            TryAutoRedraw();
        }

        /// <summary>イメージをセットする</summary>
        /// <param name="Source">セットしたいイメージ</param>
        /// <param name="X">セットしたい場所の左上端座標X</param>
        /// <param name="Y">セットしたい場所の左上端座標Y</param>
        /// <param name="Width">セットしたい場所範囲の幅 省略可</param>
        /// <param name="Height">セットしたい場所範囲の高さ 省略可</param>
        /// <param name="SourceAlpha">描画したいイメージの不透明度(0.0～1.0) 省略化 その場合1.0となる</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.ObjectPaintPicture(img,X,Y) VB6.0のPaintPicture img,X,Yと同等</para>
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">SourceAlphaの値が0.0～1.0の範囲ではない場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthかHeightに0以下を指定した場合に発生</exception>
        public void ObjectPaintPicture(System.Windows.Media.ImageSource Source, double X, double Y, [Optional]NullableClass<double> Width, [Optional]NullableClass<double> Height, [Optional]NullableClass<double> SourceAlpha)
        {
            if (this.Interrupting)
                throw new InvalidOperationException("ObjectPaintPicture : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!SourceAlpha.HasValue())
                SourceAlpha = 1.0;

            if (0.0 > SourceAlpha || SourceAlpha > 1.0)
                throw new ArgumentOutOfRangeException("SourceAlpha", "ObjectPaintPicture : SourceAlphaの値は0.0～1.0の間です。");

            Width = (Width.HasValue() ? GetValueX(Width.Value) : this.ScaleImage.PixelWidth);
            Height = (Height.HasValue() ? GetValueY(Height.Value) : this.ScaleImage.PixelHeight);

            if (Width <= 0.0 || Height <= 0.0)
                throw new ArgumentOutOfRangeException("Width , Height", "ObjectPaintPicture : WidthとHeightはプラスの値で表記してください。");

            this.TargetGraphics.Vector.SetImage(Source, new Rect(GetX(X), GetY(Y), Width.Value, Height.Value), SourceAlpha);

            this.CurrentX = X;
            this.CurrentY = Y;
        }
        #endregion

        #region その他
        /// <summary>画面消去</summary>
        public void Cls()
        {
            this.BaseGraphics.Clear();

            TryAutoRedraw();
        }

        /// <summary>指定したインデックスのオブジェクトを取得する</summary>
        /// <param name="Index">取得したいオブジェクトのインデックス</param>
        /// <returns>取得したオブジェクト</returns>
        public UIElement GetObject(int Index)
        {
            return this.TargetGraphics.Vector.GetObject(Index);
        }

        /// <summary>オブジェクトを指定位置にセットする(このPictureBox上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Obj">セットしたいオブジェクト</param>
        /// <param name="Left">オブジェクトの左端座標</param>
        /// <param name="Top">オブジェクトの上端座標</param>
        public void SetObject(UIElement Obj, double Left, double Top)
        {
            this.TargetGraphics.Vector.SetObject(Obj, Left, Top);
        }

        /// <summary>指定したインデックスのオブジェクトを移動する</summary>
        /// <param name="Index">移動したいオブジェクトのインデックス</param>
        /// <param name="X">左端の座標X</param>
        /// <param name="Y">上端の座標Y</param>
        /// <remarks>
        /// <example>メソッド使用例
        /// <para>PictureBox.MoveObject(0,10.0,10.0) 一番初めにセットしたオブジェクトを(10.0,10.0)の位置に配置しなおす</para>
        /// </example></remarks>
        public void MoveObject(int Index, double X, double Y)
        {
            this.TargetGraphics.Vector.MoveObject(Index, GetX(X), GetY(Y));
        }

        /// <summary>指定したインデックスのオブジェクトを相対的に移動する</summary>
        /// <param name="Index">移動したいオブジェクトのインデックス</param>
        /// <param name="X">現在の位置からの相対距離X</param>
        /// <param name="Y">現在の位置からの相対距離Y</param>
        /// <remarks>
        /// <example>メソッド使用例
        /// <para>PictureBox.MoveObject(0,10.0,-10.0) 一番初めにセットしたオブジェクトの位置をX方向に10.0、Y方向に-10.0ずらす</para>
        /// </example></remarks>
        public void RelativeMoveObject(int Index, double X, double Y)
        {
            this.TargetGraphics.Vector.RelativeMoveObject(Index, GetValueX(X), GetValueY(Y));
        }

        /// <summary>指定したインデックスのオブジェクトを削除する</summary>
        /// <param name="Index">削除するオブジェクトのインデックス</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.RemoveObject(0) 初めにセットしたオブジェクトを破棄する</para>
        /// </example></remarks>
        public void RemoveObject(int Index)
        {
            this.TargetGraphics.Vector.Remove(Index);
        }

        /// <summary>1つ前にセットしたオブジェクトを削除する</summary>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.BackRemoveObject() 最後に設置したオブジェクトを破棄する</para>
        /// </example></remarks>
        public void BackRemoveObject()
        {
            this.TargetGraphics.Vector.BackRemove();
        }

        /// <summary>指定した2つのインデックス位置のオブジェクトの前面背面関係を交換する</summary>
        /// <param name="Index1">1つ目のオブジェクトのインデックス</param>
        /// <param name="Index2">2つ目のオブジェクトのインデックス</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.SwapObject(0,2) 1つ目のオブジェクトと3つ目のオブジェクトの前面背面関係を交換する</para>
        /// </example></remarks>
        public void SwapObject(int Index1, int Index2)
        {
            this.TargetGraphics.Vector.SwapObject(Index1, Index2);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトのサイズを変更する</summary>
        /// <param name="Index">サイズ変更したいオブジェクトのインデックス</param>
        /// <param name="Width">オブジェクトの幅</param>
        /// <param name="Height">オブジェクトの高さ</param>
        /// <remarks>注意
        /// <para>直線など幅指定ではなく始点終点などのパラメータで指定するオブジェクトを対象にすると期待する結果にならない事があります。</para>
        /// <para>メソッドの使用例</para>
        /// <example><code>PictureBox.ResizeObject(0,300,100); //1つ目のオブジェクトを幅300、高さ100にサイズ変更する</code></example></remarks>
        public void ResizeObject(int Index, double Width, double Height)
        {
            this.TargetGraphics.Vector.ResizeObject(Index, GetValueX(Width), GetValueY(Height));
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトのサイズを相対的に変更する</summary>
        /// <param name="Index">サイズ変更したいオブジェクトのインデックス</param>
        /// <param name="X">オブジェクトの幅の相対差</param>
        /// <param name="Y">オブジェクトの高さの相対差</param>
        /// <remarks>注意
        /// <para>直線など幅指定ではなく始点終点などのパラメータで指定するオブジェクトを対象にすると期待する結果にならない事があります。</para>
        /// <para>メソッドの使用例</para>
        /// <example><code>PictureBox.RelativeResizeObject(0,-50,100); //1つ目のオブジェクトの幅を50減らして、高さを100増やす</code></example></remarks>
        public void RelativeResizeObject(int Index, double X, double Y)
        {
            this.TargetGraphics.Vector.RelativeResizeObject(Index, GetValueX(X), GetValueY(Y));
        }

        /// <summary>オブジェクトを移動する (スクリーン座標系、ピクセル単位)</summary>
        /// <param name="Left">オーナー座標(通常はForm内の座標)での左端の座標X</param>
        /// <param name="Top">オーナー座標(通常はForm内の座標)での上端の座標Y</param>
        /// <param name="Width">オブジェクトの幅</param>
        /// <param name="Height">オブジェクトの高さ</param>
        /// <remarks>
        /// <example>メソッド使用例
        /// <para>PictureBox.MoveObject(10,10,500,500) VB6.0のMove 10,10,500,500 とほぼ同等(単位はピクセルのみになる：オーナー座標(10,10)に500×500の大きさで再配置する)</para>
        /// </example></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthかHeightにマイナスの値を指定した場合に発生</exception>
        /// <exception cref="System.InvalidOperationException">このインスタンスの親がCanvasでない場合に発生</exception>
        public void Move(double Left, double Top, double Width, double Height)
        {
            if (Width < 0.0 || Height < 0.0)
                throw new ArgumentOutOfRangeException("Width , Height", "Move : WidthとHeightにマイナスの値は指定できません。");

            if (!(base.Parent is Canvas))
                throw new InvalidOperationException("Move : このインスタンスの親がCanvasでない場合にこのメソッドは使えません。");

            base.SetValue(Hierarchy.BackgroundCanvas, Canvas.LeftProperty, Left);
            base.SetValue(Hierarchy.BackgroundCanvas, Canvas.TopProperty, Top);

            base.Width = Width;
            base.Height = Height;
        }

        /// <summary>指定した座標の色(オブジェクトは除く)を返す(ColorConstants形式(ARGB形式))</summary> 
        /// <param name="X">座標X</param> 
        /// <param name="Y">座標Y</param> 
        /// <returns>色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks><example>メソッドの使用例<para>PictureBox.Point(10,10) VB6.0のPoint 10,10 と同等</para></example></remarks>
        public ColorConstants Point(double X, double Y)
        {
            return (ColorConstants)this.TargetGraphics.Raster[(int)(GetX(X) + 0.5), (int)(GetY(Y) + 0.5)];
        }

        /// <summary>現在のフォントである文字列をプリントしたときの文字列の幅を取得する</summary>
        /// <param name="Str">幅が知りたい文字列</param>
        /// <returns>Strをプリントした時の幅</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.TextWidth("ABC") VB6.0のTextWidth "ABC" と同等</para>
        /// </example></remarks>
        public double TextWidth(string Str)
        {
            return GetReverseValueX(this.TargetGraphics.Vector.MeasureString(Str, this.Font).Width);
        }

        /// <summary>現在のフォントである文字列をプリントしたときの文字列の高さを取得する</summary>
        /// <param name="Str">高さが知りたい文字列</param>
        /// <returns>Strをプリントした時の高さ</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.TextHeight("ABC") VB6.0のTextHeight "ABC" と同等</para>
        /// </example></remarks>
        public double TextHeight(string Str)
        {
            return GetReverseValueY(this.TargetGraphics.Vector.MeasureString(Str, this.Font).Height);
        }
        #endregion

        #endregion
    }
    #endregion

    #region PictureBoxEditVectorクラス
    /// <summary>PictureBox用のEditVector</summary>
    /// <remarks>補足
    /// <para>この編集クラスでのメソッドではオブジェクトの種類が重要になります。</para>
    /// <para>ObjectLine、ObjectPrint、ObjectPaintPictureは別の種類ですが、ObjectPSetとObjectCircleを同じ種類に数えられます。</para>
    /// <para>このクラスのメソッドで扱うオブジェクトとPictureBoxで作成するオブジェクトの種類は同じです。</para>
    /// <para>このクラスの使用例</para>
    /// <example><code><para>Dim PE As PictureBoxEditVector = New PictureBoxEditVector(Pic,VG.EditKind) 'PicはVB60.PictureBox、VGはSystem.NetFramework.VectorGraphics</para>
    /// <para>PE.ObjectLine(0,50,50,100,100) 'ObjectLineメソッドで作成した1番始めのオブジェクト(GraphicsStyle.LineStyle.Lineのスタイルで作成したオブジェクト)を 50,50 から 100,100 を繋ぐ線に編集する</para></code></example></remarks>
    public class PictureBoxEditVector
    {
        private PictureBox Target;
        private EditVector BaseEdit;

        #region プロパティ・コンストラクタ・隠蔽メソッド
        /// <summary>枠を編集する時にDrawPenのパラメータを使用するかどうか</summary>
        public bool UseDrawPen { get; set; }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">座標変換対象のPictureBox</param>
        /// <param name="Base">このクラスの基となるEditVector</param>
        /// <exception cref="System.ArgumentNullException">TargetとBaseのどちらかがnullの場合に発生</exception>
        public PictureBoxEditVector(PictureBox Target, EditVector Base)
        {
            if (Target == null || Base == null) throw new ArgumentNullException("Target , Base", "TargetとBaseにオブジェクトが参照されていない状態は許可されません。");
            this.Target = Target;
            this.BaseEdit = Base;
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的Equals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return Object.Equals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的ReferenceEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return Object.ReferenceEquals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetType</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Type GetType()
        {
            return base.GetType();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetHashCode</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのToString</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        }
        #endregion

        #region 図形描画
        /// <summary>直線を編集する</summary> 
        /// <param name="Index">編集するオブジェクトのインデックス</param>
        /// <param name="X1">始点X 省略可</param>
        /// <param name="Y1">始点Y 省略可</param>
        /// <param name="X2">終点X 省略可</param>
        /// <param name="Y2">終点Y 省略可</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="LineStyle">直線のスタイル 省略可 その場合Lineとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBoxEditVector.ObjectLine(X,Y) VB6.0のline -(X,Y)と同等</para> 
        /// <para>PictureBoxEditVector.ObjectLine(X1,Y1,X2,Y2) VB6.0のline (X1,Y1) - (X2,Y2)と同等</para> 
        /// <para>PictureBoxEditVector.ObjectLine(X1,Y1,X2,Y2,Information.QBColor(2),GraphicsStyle.LineStyle.BF) VB6.0のline (X1,Y1) - (X2,Y2),QBColor(2),BFと同等</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">X1とY1、X2とY2を同時に指定しなかった場合に発生</exception>
        /// <exception cref="System.ArgumentException">X1とY1を指定しないでX2とY2の値を指定した場合に発生</exception>
        /// <exception cref="System.InvalidCastException">指定したIndexで得たオブジェクトの型とこのメソッドで指定したLineStyleの型が一致しない場合に発生</exception>
        public void ObjectLine(int Index, [Optional]NullableClass<double> X1, [Optional]NullableClass<double> Y1, [Optional]NullableClass<double> X2, [Optional]NullableClass<double> Y2, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<GraphicsStyle.LineStyle> LineStyle)
        {
            if (this.Target.Interrupting)
                throw new InvalidOperationException("ObjectLine : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!(X1.HasValue() == Y1.HasValue()) || !(X2.HasValue() == Y2.HasValue()))
                throw new ArgumentException("ObjectLine : X1とY1、X2とY2の値は同時に指定してください。", "X1 , Y1 , X2 , Y2");

            else if(X1.HasValue() == false && X2.HasValue()==true)
                throw new ArgumentException("ObjectLine : X1とY1を指定しないでX2とY2の値を指定する事は出来ません。", "X1 , Y1 , X2 , Y2");

            if (!LineStyle.HasValue())
                LineStyle = GraphicsStyle.LineStyle.Line;

            //X2,Y2が省略された場合Current～を始点X1,Y1を終点とする
            if (X1.HasValue() && !X2.HasValue())
            {
                X2 = X1;
                X1 = this.Target.CurrentX;
                Y2 = Y1;
                Y1 = this.Target.CurrentY;
            }

            UIElement elm = this.BaseEdit.GetUIElementMethod(Index, ObjectType.Line | ObjectType.Rectangle);

            //Line
            if (LineStyle == GraphicsStyle.LineStyle.Line)
            {
                Line line =  (Line)elm;

                if (X1.HasValue())
                {
                    line.X1 = this.Target.GetX(X1);
                    line.X2 = this.Target.GetX(X2);
                    line.Y1 = this.Target.GetY(Y1);
                    line.Y2 = this.Target.GetY(Y2);
                }

                if (this.UseDrawPen) this.BaseEdit.Line(line, this.Target.DrawPen);

                if (DrawColor.HasValue())
                    line.Stroke = new SolidColorBrush(((int)DrawColor.Value).ToColor());
            }

            else
            {
                Rectangle rectangle = (Rectangle)elm;

                if (X1.HasValue())
                {
                    rectangle.SetValue(Canvas.LeftProperty, this.Target.GetX(X1) < this.Target.GetX(X2.Value) ? this.Target.GetX(X1) : this.Target.GetX(X2.Value));
                    rectangle.Width = this.Target.GetX(X1) < this.Target.GetX(X2.Value) ? this.Target.GetX(X2.Value) - this.Target.GetX(X1) : this.Target.GetX(X1) - this.Target.GetX(X2.Value);
                    rectangle.SetValue(Canvas.TopProperty, this.Target.GetY(Y1) < this.Target.GetY(Y2.Value) ? this.Target.GetY(Y1) : this.Target.GetY(Y2.Value));
                    rectangle.Height = this.Target.GetY(Y1) < this.Target.GetY(Y2.Value) ? this.Target.GetY(Y2.Value) - this.Target.GetY(Y1) : this.Target.GetY(Y1) - this.Target.GetY(Y2.Value);
                }

                //FillRectangle
                if (LineStyle == GraphicsStyle.LineStyle.FillRectangle)
                {
                    if (DrawColor.HasValue())
                        rectangle.Fill = new SolidColorBrush(((int)DrawColor.Value).ToColor());
                }

                //Rectangle
                else
                {
                    if (this.Target.FillStyle != FillStyleConstants.vbFSTransparent)
                        rectangle.Fill = (SolidColorBrush)this.Target.FillBrush;

                    else
                        rectangle.Fill = new SolidColorBrush(Color.FromArgb(0, 0, 0, 0));

                    if (DrawColor.HasValue())
                        rectangle.Stroke = new SolidColorBrush(((int)DrawColor.Value).ToColor());
                }
            }

            if (X2.HasValue())
            {
                this.Target.CurrentX = X2.Value;
                this.Target.CurrentY = Y2.Value;
            }

            if (DrawColor.HasValue())
                this.Target.ForeColor = DrawColor.Value;
        }

        /// <summary>点を編集する(塗りつぶし楕円)</summary> 
        /// <param name="Index">編集するオブジェクトのインデックス</param>
        /// <param name="X">中心の座標X 省略可</param> 
        /// <param name="Y">中心の座標Y 省略可</param> 
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param> 
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBoxEditVector.ObjectPSet(X,Y) VB6.0のPSet (X,Y)と同等</para> 
        /// <para>PictureBoxEditVector.ObjectPSet(X,Y,Information.QBColor(3)) VB6.0のPSet (X,Y),QBColor(3)と同等</para> 
        /// </example></remarks> 
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">XとYを同時に指定しなかった場合に発生</exception>
        /// <exception cref="System.InvalidCastException">指定したIndexで得たオブジェクトの型とこのメソッドでの型が一致しない場合に発生</exception>
        public void ObjectPSet(int Index, [Optional]NullableClass<double> X, [Optional]NullableClass<double> Y, [Optional]NullableClass<ColorConstants> DrawColor)
        {
            if (this.Target.Interrupting)
                throw new InvalidOperationException("ObjectPSet : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (X.HasValue() ^ Y.HasValue()) throw new ArgumentException("ObjectPSet : XとYの値は同時に指定してください。", "X , Y");

            Ellipse ellipse = (Ellipse)this.BaseEdit.GetUIElementMethod(Index, ObjectType.Ellipse);

            if (X.HasValue())
            {
                ellipse.SetValue(Canvas.LeftProperty, this.Target.GetX(X) - 1.5);
                ellipse.SetValue(Canvas.TopProperty, this.Target.GetY(Y) - 1.5);
                ellipse.Width = 3.0;
                ellipse.Height = 3.0;

                this.Target.CurrentX = X;
                this.Target.CurrentY = Y;
            }

            if (DrawColor.HasValue())
            {
                ellipse.Fill = new SolidColorBrush(((int)DrawColor.Value).ToColor());

                this.Target.ForeColor = DrawColor.Value;
            }
        }

        /// <summary>円を編集する</summary> 
        /// <param name="Index">編集するオブジェクトのインデックス</param>
        /// <param name="X">中心の座標X 省略可</param> 
        /// <param name="Y">中心の座標Y 省略可</param> 
        /// <param name="R">半径を指定 0.0より大きい値(X軸の単位) 省略可</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="Aspect">アスペクト比(縦/横) 省略可 その場合1.0となる</param>
        /// <param name="CircleStyle">円のスタイル(VB6.0での円弧・扇形の指定はここで) 省略可 その場合Arcとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBoxEditVector.ObjectCircle(X,Y,R) VB6.0のCircle (X,Y),Rと同等</para> 
        /// <para>PictureBoxEditVector.ObjectCircle(X,Y,R,C, , ,ASP) VB6.0のCircle (X,Y),R,C, , ,ASPと同等(C:色 ASP:アスペクト比)</para> 
        /// </example></remarks> 
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Rの値が0以下になっている場合に発生</exception>
        /// <exception cref="System.ArgumentException">XとYとRを同時に指定しなかった場合に発生</exception>
        /// <exception cref="System.InvalidCastException">指定したIndexで得たオブジェクトの型とこのメソッドでの型が一致しない場合に発生</exception>
        public void ObjectCircle(int Index, [Optional]NullableClass<double> X, [Optional]NullableClass<double> Y, [Optional]NullableClass<double> R, [Optional]NullableClass<ColorConstants> DrawColor, [Optional]NullableClass<double> Aspect, [Optional]NullableClass<GraphicsStyle.ObjectCircleStyle> CircleStyle)
        {
            if (this.Target.Interrupting)
                throw new InvalidOperationException("ObjectCircle ： Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!(X.HasValue() == Y.HasValue()) || !(Y.HasValue() == R.HasValue())) throw new ArgumentException("ObjectCircle : XとYとRの値は同時に指定してください。", "X , Y , R");

            if (!CircleStyle.HasValue())
                CircleStyle = GraphicsStyle.ObjectCircleStyle.Circle;

            Ellipse ellipse = (Ellipse)this.BaseEdit.GetUIElementMethod(Index, ObjectType.Ellipse);

            if (R.HasValue())
            {
                if (R <= 0.0)
                    throw new ArgumentOutOfRangeException("R", "ObjectCircle ： Rの値は0.0より大きい値で指定してください。");

                double SHX, SHY;

                if (Aspect.HasValue())
                {
                    //アスペクト比に従ってXの半径とYの半径を決める
                    SHX = this.Target.GetValueX(Aspect < 1.0 ? R.Value / Aspect.Value : R.Value);
                    SHY = this.Target.GetValueX(Aspect > 1.0 ? R.Value * Aspect.Value : R.Value);
                }

                else
                {
                    SHX = this.Target.GetValueX(R);
                    SHY = this.Target.GetValueX(R);
                }

                ellipse.SetValue(Canvas.LeftProperty, this.Target.GetX(X) - SHX);
                ellipse.SetValue(Canvas.TopProperty, this.Target.GetY(Y) - SHY);
                ellipse.Width = SHX * 2.0;
                ellipse.Height = SHY * 2.0;
            }

            //FillCircle
            if (CircleStyle == GraphicsStyle.ObjectCircleStyle.FillCircle)
            {
                if (DrawColor.HasValue())
                    ellipse.Fill = new SolidColorBrush(((int)DrawColor.Value).ToColor());
            }

            //Circle
            else
            {
                if (this.Target.FillStyle != FillStyleConstants.vbFSTransparent)
                    ellipse.Fill = (SolidColorBrush)this.Target.FillBrush;

                else
                    ellipse.Fill = new SolidColorBrush(Color.FromArgb(0, 0, 0, 0));

                if (DrawColor.HasValue())
                    ellipse.Stroke = new SolidColorBrush(((int)DrawColor.Value).ToColor());
            }

            if (X.HasValue())
            {
                this.Target.CurrentX = X;
                this.Target.CurrentY = Y;
            }

            if (DrawColor.HasValue())
                this.Target.ForeColor = DrawColor.Value;
        }
        #endregion

        #region テキスト・画像描画
        /// <summary>文字列を編集する(フォントはプロパティFont、フォントカラーはプロパティDrawColorまたは指定した色に依存)</summary>
        /// <param name="Index">編集するオブジェクトのインデックス</param>
        /// <param name="DrawString">セットしたい文字列</param>
        /// <param name="X">文字列の左上端座標のX 省略可 その場合CurrentXの値を使用</param>
        /// <param name="Y">文字列の左上端座標のY 省略可 その場合CurrentYの値を使用</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBoxEditVector.ObjectPrint("ABC") VB6.0のPrint "ABC"同等(Curent～で予めX,Yを決めておく)</para> 
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">XとYの値を同時に指定しないで呼び出した場合に発生</exception>
        /// <exception cref="System.InvalidCastException">指定したIndexで得たオブジェクトの型とこのメソッドでの型が一致しない場合に発生</exception>
        public void ObjectPrint(int Index, [Optional]string DrawString, [Optional]NullableClass<double> X, [Optional]NullableClass<double> Y, [Optional]NullableClass<ColorConstants> DrawColor)
        {
            if (this.Target.Interrupting)
                throw new InvalidOperationException("ObjectPrint : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!X.HasValue() ^ !Y.HasValue())
                throw new ArgumentException("ObjectPrint : XとYの値は同時に指定してください。", "X , Y");

            TextBlock tb = (TextBlock)this.BaseEdit.GetUIElementMethod(Index, ObjectType.String);

            //X,Yが与えられなかった場合Current～を使う
            if (X.HasValue())
            {
                tb.SetValue(Canvas.LeftProperty, this.Target.GetX(X));
                tb.SetValue(Canvas.TopProperty, this.Target.GetY(Y));

                this.Target.CurrentX = X.Value;
                this.Target.CurrentY = Y.Value;
            }

            if (DrawColor.HasValue())
            {
                tb.Foreground = new SolidColorBrush(((int)DrawColor.Value).ToColor());

                this.Target.ForeColor = DrawColor.Value;
            }
        }

        /// <summary>イメージを編集する</summary>
        /// <param name="Index">編集するオブジェクトのインデックス</param>
        /// <param name="Source">セットしたいイメージ 省略可</param>
        /// <param name="X">セットしたい場所の左上端座標X 省略可</param>
        /// <param name="Y">セットしたい場所の左上端座標Y 省略可</param>
        /// <param name="Width">セットしたい場所範囲の幅 省略可</param>
        /// <param name="Height">セットしたい場所範囲の高さ 省略可</param>
        /// <param name="SourceAlpha">描画したいイメージの不透明度(0.0～1.0) 省略化</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBoxEditVector.ObjectPaintPicture(Index,img,X,Y) //Indexのオブジェクトのimg,X,Yを編集する</para>
        /// </example></remarks>
        /// <exception cref="System.InvalidOperationException">Starting_Initしていない状態またはInterruptしている状態で実行すると発生</exception>
        /// <exception cref="System.ArgumentException">XとYの値を同時に指定しないで呼び出した場合に発生</exception>
        /// <exception cref="System.ArgumentException">WidthかHeightの値を同時に指定しないで呼び出した場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">SourceAlphaの値が0.0～1.0の範囲ではない場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthかHeightに0以下を指定した場合に発生</exception>
        /// <exception cref="System.InvalidCastException">指定したIndexで得たオブジェクトの型とこのメソッドでの型が一致しない場合に発生</exception>
        public void ObjectPaintPicture(int Index, [Optional]System.Windows.Media.ImageSource Source, [Optional]NullableClass<double> X, [Optional]NullableClass<double> Y, [Optional]NullableClass<double> Width, [Optional]NullableClass<double> Height, [Optional]NullableClass<double> SourceAlpha)
        {
            if (this.Target.Interrupting)
                throw new InvalidOperationException("ObjectPaintPicture : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。");

            if (!X.HasValue() ^ !Y.HasValue())
                throw new ArgumentException("ObjectPaintPicture : XとYの値は同時に指定してください。", "X , Y");

            if (!Width.HasValue() ^ !Height.HasValue())
                throw new ArgumentException("ObjectPaintPicture : WidthとHeightの値は同時に指定してください。", "Width , Height");

            Image img = (Image)this.BaseEdit.GetUIElementMethod(Index, ObjectType.Image);

            if (SourceAlpha.HasValue())
            {
                if (0.0 > SourceAlpha || SourceAlpha > 1.0)
                    throw new ArgumentOutOfRangeException("SourceAlpha", "ObjectPaintPicture : SourceAlphaの値は0.0～1.0の間です。");

                img.Opacity = SourceAlpha;
            }

            if (X.HasValue())
            {
                img.SetValue(Canvas.LeftProperty, this.Target.GetX(X));
                img.SetValue(Canvas.TopProperty, this.Target.GetY(Y));

                this.Target.CurrentX = X;
                this.Target.CurrentY = Y;
            }

            if (Width.HasValue())
            {
                if (Width <= 0.0 || Height <= 0.0)
                    throw new ArgumentOutOfRangeException("Width , Height", "ObjectPaintPicture : WidthとHeightはプラスの値で表記してください。");

                img.Width = this.Target.GetValueX(Width.Value);
                img.Height = this.Target.GetValueY(Height.Value);
            }

            if (Source != null)
                img.Source = Source;
        }
        #endregion
    }
    #endregion

    #region PictureBoxUnitConvertクラス
    /// <summary>単位変換メソッドのみを管理するクラス VB60.PictureBoxから単位変換メソッドのみを抜き出してインスタンスを作る</summary>
    /// <remarks>クラスの利用方法(VB.NET)
    /// <para>Dim A As VB60.PictureBox = New VB60.PictureBox()</para>
    /// <para>A.YAxialDirection = AxialDirectionConstants.YAxial.Top等</para>
    /// <para>A.Init_Scale(-1,1,2,2) →数学座標の-1～1の幅高さそれぞれ2の仮想座標の設定</para>
    /// <para>A.Starting_Init()</para>
    /// <para>Dim B As VB60.PictureBoxUnitConvert = New VB60.PictureBoxUnitConvert(A)</para>
    /// <para>Dim C As Single = B.GetX(0)等と使う</para>
    /// <para> </para>
    /// <para>以下単位変換メソッドの説明</para>
    /// <para>単位変換メソッドはGet～という名前で定義されている</para>
    /// <para>GetXなどはScaleModeの座標系からピクセル単位のスクリーン座標系に変換する通常メソッド</para>
    /// <para>GetReverseXなどReverseが付くと先ほどの通常変換の逆変換になる</para>
    /// <para>GetValueXなどValueが付くものは原点関係なしで幅や高さを取得する変換メソッドである</para>
    /// <para>GetArrayXなどArrayが付くものは配列に関する変換メソッドである</para>
    /// <para>Get～の一番右側が取得する値の種類を表す(種類：X,Y,Point,Size,Array)</para>
    /// <para>GetStepXなどの特殊変換も存在する</para>
    /// <para>省略はGetを除いた単語の先頭のアルファベットを並べた物である</para>
    /// <para>例えばGetReverseValueArraySizeの省略はRVASである</para>
    /// </remarks>
    public class PictureBoxUnitConvert
    {
        #region フィールドとコンストラクタ、隠蔽メソッド
        /// <summary>単位変換の対象となるVB60.PictureBox</summary>
        private PictureBox Target;
        /// <summary>単位変換メソッドの詳細をメソッド一覧に表示するかどうかのパラメータ</summary>
        private const EditorBrowsableState EBState = EditorBrowsableState.Advanced;

        /// <summary>新しくインスタンスを作る</summary>
        /// <param name="Target">単位変換の対象となるVB60.PictureBox</param>
        /// <exception cref="System.ArgumentException">単位変換対象となるPictureBoxがnullまたはStarting_Initしていない場合に発生</exception>
        public PictureBoxUnitConvert(PictureBox Target)
        {
            if (Target == null || !Target.StartEnabled)
                throw new ArgumentException("コンストラクタ : 引数のVB60.PictureBoxがNothing(null)またはStarting_Initをしていない状態でこのクラスのインスタンスは作れません。", "Target");

            this.Target = Target;
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的Equals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return Object.Equals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的ReferenceEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return Object.ReferenceEquals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetType</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Type GetType()
        {
            return base.GetType();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetHashCode</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのToString</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        } 
        #endregion

        #region 単位変換メソッド

        #region 通常変換
        /// <summary>GetX() : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetX()</para></remarks>
        public double X(double Value)
        {
            return GetX(Value);
        }

        /// <summary>GetY() : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetY()</para></remarks>
        public double Y(double Value)
        {
            return GetY(Value);
        }

        /// <summary>GetArrayX() : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayX()</para></remarks>
        public double[] AX(double[] Value)
        {
            return GetArrayX(Value);
        }

        /// <summary>GetArrayY() : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayY()</para></remarks>
        public double[] AY(double[] Value)
        {
            return GetArrayY(Value);
        }

        /// <summary>GetValueX() : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueX()</para></remarks>
        public double VX(double Value)
        {
            return GetValueX(Value);
        }

        /// <summary>GetValueY() : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueY()</para></remarks>
        public double VY(double Value)
        {
            return GetValueY(Value);
        }

        /// <summary>GetValueArrayX() : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayX()</para></remarks>
        public double[] VAX(double[] Value)
        {
            return GetValueArrayX(Value);
        }

        /// <summary>GetValueArrayY() : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayY()</para></remarks>
        public double[] VAY(double[] Value)
        {
            return GetValueArrayY(Value);
        }

        /// <summary>GetPoint() : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        /// <remarks>内部アクセス名<para>GetPoint()</para></remarks>
        public Point P(Point Value)
        {
            return GetPoint(Value);
        }

        /// <summary>GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetArrayPoint()</para></remarks>
        public Point[] AP(Point[] Value)
        {
            return GetArrayPoint(Value);
        }

        /// <summary>GetValueSize() : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetValueSize()</para></remarks>
        public Size VS(Size Value)
        {
            return GetValueSize(Value);
        }

        /// <summary>GetValueArraySize() : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArraySize()</para></remarks>
        public Size[] VAS(Size[] Value)
        {
            return GetValueArraySize(Value);
        }
        #endregion

        #region 逆変換
        /// <summary>GetReverseX() : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseX()</para></remarks>
        public double RX(double Value)
        {
            return GetReverseX(Value);
        }

        /// <summary>GetReverseY() : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseY()</para></remarks>
        public double RY(double Value)
        {
            return GetReverseY(Value);
        }

        /// <summary>GetReverseArrayX() : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayX()</para></remarks>
        public double[] RAX(double[] Value)
        {
            return GetReverseArrayX(Value);
        }

        /// <summary>GetReverseArrayY() : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayY()</para></remarks>
        public double[] RAY(double[] Value)
        {
            return GetReverseArrayY(Value);
        }

        /// <summary>GetReverseValueX() : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueX()</para></remarks>
        public double RVX(double Value)
        {
            return GetReverseValueX(Value);
        }

        /// <summary>GetReverseValueY() : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueY()</para></remarks>
        public double RVY(double Value)
        {
            return GetReverseValueY(Value);
        }

        /// <summary>GetReverseValueArrayX() : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayX()</para></remarks>
        public double[] RVAX(double[] Value)
        {
            return GetReverseValueArrayX(Value);
        }

        /// <summary>GetReverseValueArrayY() : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayY()</para></remarks>
        public double[] RVAY(double[] Value)
        {
            return GetReverseValueArrayY(Value);
        }

        /// <summary>GetReversePoint() : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        /// <remarks>内部アクセス名<para>GetReversePoint()</para></remarks>
        public Point RP(Point Value)
        {
            return GetReversePoint(Value);
        }

        /// <summary>GetReverseArrayPoint() : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayPoint()</para></remarks>
        public Point[] RAP(Point[] Value)
        {
            return GetReverseArrayPoint(Value);
        }

        /// <summary>GetReverseValueSize() : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueSize()</para></remarks>
        public Size RVS(Size Value)
        {
            return GetReverseValueSize(Value);
        }

        /// <summary>GetReverseValueArraySize() : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArraySize()</para></remarks>
        public Size[] RVAS(Size[] Value)
        {
            return GetReverseValueArraySize(Value);
        }
        #endregion

        #region その他の変換
        /// <summary>GetStepX() : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepX()</para></remarks>
        public double SX(double Value)
        {
            return GetStepX(Value);
        }

        /// <summary>GetStepY() : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepY()</para></remarks>
        public double SY(double Value)
        {
            return GetStepY(Value);
        }

        /// <summary>GetStepArrayX() : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayX()</para></remarks>
        public double[] SAX(double[] Value)
        {
            return GetStepArrayX(Value);
        }

        /// <summary>GetStepArrayY() : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayY()</para></remarks>
        public double[] SAY(double[] Value)
        {
            return GetStepArrayY(Value);
        }

        /// <summary>GetStepPoint() : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        /// <remarks>内部アクセス名<para>GetStepPoint()</para></remarks>
        public Point SP(Point Value)
        {
            return GetStepPoint(Value);
        }

        /// <summary>GetStepArrayPoint() : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayPoint()</para></remarks>
        public Point[] SAP(Point[] Value)
        {
            return GetStepArrayPoint(Value);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public double[] PA(double[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Point[] PA(Point[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Size[] PA(Size[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public double[] PA(double[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Point[] PA(Point[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public Size[] PA(Size[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #region メソッドの中身の記述

        #region 内部通常変換
        /// <summary>X : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="X">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns>
        [EditorBrowsable(EBState)]
        public double GetX(double X)
        {
            return this.Target.GetX(X);
        }

        /// <summary>Y : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Y">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        [EditorBrowsable(EBState)]
        public double GetY(double Y)
        {
            return this.Target.GetY(Y);
        }

        /// <summary>AX : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="X">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetArrayX(double[] X)
        {
            return this.Target.GetArrayX(X);
        }

        /// <summary>AY : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Y">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetArrayY(double[] Y)
        {
            return this.Target.GetArrayY(Y);
        }

        /// <summary>VX : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="VX">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        [EditorBrowsable(EBState)]
        public double GetValueX(double VX)
        {
            return this.Target.GetValueX(VX);
        }

        /// <summary>VY : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="VY">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        [EditorBrowsable(EBState)]
        public double GetValueY(double VY)
        {
            return this.Target.GetValueY(VY);
        }

        /// <summary>VAX : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="VX">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetValueArrayX(double[] VX)
        {
            return this.Target.GetValueArrayX(VX);
        }

        /// <summary>VAY : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="VY">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetValueArrayY(double[] VY)
        {
            return this.Target.GetValueArrayY(VY);
        }

        /// <summary>P : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="P">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        [EditorBrowsable(EBState)]
        public Point GetPoint(Point P)
        {
            return this.Target.GetPoint(P);
        }

        /// <summary>AP : GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="P">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public Point[] GetArrayPoint(Point[] P)
        {
            return this.Target.GetArrayPoint(P);
        }

        /// <summary>VS : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="S">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        [EditorBrowsable(EBState)]
        public Size GetValueSize(Size S)
        {
            return this.Target.GetValueSize(S);
        }

        /// <summary>VAS : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="S">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        [EditorBrowsable(EBState)]
        public Size[] GetValueArraySize(Size[] S)
        {
            return this.Target.GetValueArraySize(S);
        }
        #endregion

        #region 内部逆変換
        /// <summary>RX : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="X">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        [EditorBrowsable(EBState)]
        public double GetReverseX(double X)
        {
            return this.Target.GetReverseX(X);
        }

        /// <summary>RY : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Y">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        [EditorBrowsable(EBState)]
        public double GetReverseY(double Y)
        {
            return this.Target.GetReverseY(Y);
        }

        /// <summary>RAX : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="X">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetReverseArrayX(double[] X)
        {
            return this.Target.GetReverseArrayX(X);
        }

        /// <summary>RAY : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Y">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetReverseArrayY(double[] Y)
        {
            return this.Target.GetReverseArrayY(Y);
        }

        /// <summary>RVX : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="VX">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        [EditorBrowsable(EBState)]
        public double GetReverseValueX(double VX)
        {
            return this.Target.GetReverseValueX(VX);
        }

        /// <summary>RVY : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="VY">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        [EditorBrowsable(EBState)]
        public double GetReverseValueY(double VY)
        {
            return this.Target.GetReverseValueY(VY);
        }

        /// <summary>RVAX : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="VX">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetReverseValueArrayX(double[] VX)
        {
            return this.Target.GetReverseValueArrayX(VX);
        }

        /// <summary>RVAY : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="VY">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        [EditorBrowsable(EBState)]
        public double[] GetReverseValueArrayY(double[] VY)
        {
            return this.Target.GetReverseValueArrayY(VY);
        }

        /// <summary>RP : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="P">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        [EditorBrowsable(EBState)]
        public Point GetReversePoint(Point P)
        {
            return this.Target.GetReversePoint(P);
        }

        /// <summary>RAP : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="P">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        [EditorBrowsable(EBState)]
        public Point[] GetReverseArrayPoint(Point[] P)
        {
            return this.Target.GetReverseArrayPoint(P);
        }

        /// <summary>RVS : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="S">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        [EditorBrowsable(EBState)]
        public Size GetReverseValueSize(Size S)
        {
            return this.Target.GetReverseValueSize(S);
        }

        /// <summary>RVAS : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="S">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        [EditorBrowsable(EBState)]
        public Size[] GetReverseValueArraySize(Size[] S)
        {
            return this.Target.GetReverseValueArraySize(S);
        }
        #endregion

        #region 内部その他の変換
        /// <summary>SX : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="X">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        [EditorBrowsable(EBState)]
        public double GetStepX(double X)
        {
            return this.Target.GetStepX(X);
        }

        /// <summary>SY : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Y">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        [EditorBrowsable(EBState)]
        public double GetStepY(double Y)
        {
            return this.Target.GetStepY(Y);
        }

        /// <summary>SAX : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="X">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public double[] GetStepArrayX(double[] X)
        {
            return this.Target.GetStepArrayX(X);
        }

        /// <summary>SAY : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Y">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public double[] GetStepArrayY(double[] Y)
        {
            return this.Target.GetStepArrayY(Y);
        }

        /// <summary>SP : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="P">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        [EditorBrowsable(EBState)]
        public Point GetStepPoint(Point P)
        {
            return this.Target.GetStepPoint(P);
        }

        /// <summary>SAP : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="P">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public Point[] GetStepArrayPoint(Point[] P)
        {
            return this.Target.GetStepArrayPoint(P);
        }

        /// <summary>PA : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public double[] GetPartialArray(double[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>PA : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public Point[] GetPartialArray(Point[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>PA : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        [EditorBrowsable(EBState)]
        public Size[] GetPartialArray(Size[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #endregion

        #endregion
    }
    #endregion
}
#endregion

#region .Net Frameworkに関するオブジェクトを保有するネームスペース
namespace System.NetFramework
{
    #region 列挙体
    /// <summary>ダッシュと空白の破線パターンの既定値を示す</summary>
    public enum DashStyle
    {
        /// <summary>実線</summary> 
        Solid,
        /// <summary>ダッシュで構成される直線</summary> 
        Dash,
        /// <summary>ドットで構成される直線</summary> 
        Dot,
        /// <summary>ダッシュとドットの繰り返しパターンで構成される直線</summary> 
        DashDot,
        /// <summary>ダッシュと 2 つのドットの繰り返しパターンで構成される直線</summary> 
        DashDotDot,
        /// <summary>ユーザー定義のカスタム ダッシュ スタイルを指定します。</summary>
        Custom
    }

    /// <summary>パターンによる塗りつぶしのスタイル</summary>
    public enum HatchStyle
    {
        /// <summary>水平線のパターン</summary>
        Horizontal,
        /// <summary>垂直線のパターン</summary>
        Vertical,
        /// <summary>左上から右下への対角線のパターン</summary>
        ForwardDiagonal,
        /// <summary>右上から左下への対角線のパターン</summary>
        BackwardDiagonal,
        /// <summary>交差する水平および垂直の線を指定します</summary>
        Cross,
        /// <summary>十字模様の対角線のパターン</summary>
        DiagonalCross
    }

    /// <summary>ラスターオペレーション定数</summary>
    /// <remarks>この列挙体で出てくる説明の中の記号は以下の通り
    /// <para>Dest:デスティネーションビットマップ(転送先のビットマップ)</para>
    /// <para>Src:ソースビットマップ(転送元のビットマップ)</para>
    /// <para>Pat:パターンカラー(転送先で設定されているパターンカラー)</para>
    /// <para> </para>
    /// <para>SrcCopy以下のSrcのα値はRGBの濃さに設定される(元のRGBをα値#FFの時とする)</para></remarks>
    public enum RasterOperation : int
    {
        /// <summary>Dest α Src : ディスティネーションビットマップとソースビットマップをαブレンド</summary>
        SrcAlpha,
        /// <summary>Dest + Src : ディスティネーションビットマップにソースビットマップを加算(+)</summary>
        SrcAdd,
        /// <summary>Dest - Src : ディスティネーションビットマップからソースビットマップを減算(-)</summary>
        SrcSub,
        /// <summary>Dest * Src : ディスティネーションビットマップにソースビットマップを乗算(*)</summary>
        SrcMul,
        /// <summary>Dest / Src : ディスティネーションビットマップからソースビットマップを除算(/)</summary>
        SrcDiv,
        /// <summary>Src : ソースビットマップを、デスティネーションビットマップにコピー</summary>
        SrcCopy = 0xcc0020,
        /// <summary>Dest OR Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(OR)</summary>
        SrcPaint = 0xee0086,
        /// <summary>Dest And Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(AND)</summary>
        SrcAnd = 0x8800c6,
        /// <summary>Dest XOR Src : デスティネーションビットマップと、ソースビットマップのピクセルを合成(XOR)</summary>
        SrcInvert = 0x660046,
        /// <summary>NOT Dest AND Src : デスティネーションビットマップを反転させた結果と、ソースビットマップのピクセルを合成(AND)</summary>
        SrcErase = 0x440328,
        /// <summary>NOT Src : ソースビットマップを反転させた結果を、デスティネーションビットマップにコピー</summary>
        NotSrcCopy = 0x330008,
        /// <summary>NOT (Dest OR Src) : デスティネーションビットマップと、ソースビットマップのピクセルを合成した結果を反転(OR)</summary>
        NotSrcErase = 0x1100a6,
        /// <summary>Pat AND Src : パターンとソースビットマップを合成(AND)</summary>
        MergeCopy = 0xc000ca,
        /// <summary>Dest OR Not Src : 反転したソースビットマップをデスティネーションビットマップに合成(OR)</summary>
        MergePaint = 0xbb0226,
        /// <summary>Pat : パターンをデスティネーションビットマップにコピー</summary>
        PatCopy = 0xf00021,
        /// <summary>Dest OR Pat : デスティネーションビットマップをパターンと合成(OR)</summary>
        PatPaint = 0xfb0a09,
        /// <summary>Dest XOR Pat : パターンをデスティネーションビットマップと合成(XOR)</summary>
        PatInvert = 0x5a0049,
        /// <summary>NOT Dest : デスティネーションビットマップを反転</summary>
        DstInvert = 0x550009,
        /// <summary>Black : 黒で塗りつぶす</summary>
        Blackness = 0x42,
        /// <summary>White : 白で塗りつぶす</summary>
        Whiteness = 0xff0062
    }

    /// <summary>使用フォントを表す列挙体(この列挙体に「.ToString().Replace('_',' ')」を付けるとそのままFontFamilyのコンストラクタに使える)</summary>
    public enum FontFamilyConstants
    {
        /// <summary>Arial</summary>
        Arial,
        /// <summary>Arial Black</summary>
        Arial_Black,
        /// <summary>Comic Sans MS</summary>
        Comic_Sans_MS,
        /// <summary>Courier New</summary>
        Courier_New,
        /// <summary>Georgia</summary>
        Georgia,
        /// <summary>Lucida Grande</summary>
        Lucida_Grande,
        /// <summary>Lucida Sans Unicode</summary>
        Lucida_Sans_Unicode,
        /// <summary>Times New Roman</summary>
        Times_New_Roman,
        /// <summary>Trebuchet MS</summary>
        Trebuchet_MS,
        /// <summary>Verdana</summary>
        Verdana
    }

    /// <summary>描画時の品質を決める</summary>
    public enum SmoothingMode
    {
        /// <summary>アンチエイリアス処理しないことを指定する</summary>
        Default,
        /// <summary>アンチエイリアス処理されたレタリングを指定する</summary>
        HighQuality,
        /// <summary>アンチエイリアス処理しないことを指定する</summary>
        HighSpeed = Default,
        /// <summary>アンチエイリアス処理しないことを指定する</summary>
        None = Default,
        /// <summary>アンチエイリアス処理されたレタリングを指定する</summary>
        AntiAlias = HighQuality
    }

    /// <summary>イメージと図形の上塗りの方式を決める</summary>
    public enum CompositingMode
    {
        /// <summary>色がレンダリングされるときに、背景色とのブレンドを指定する</summary>
        SourceOver,
        /// <summary>色がレンダリングされるときに、背景色を上書きすることを指定する</summary>
        SourceCopy
    }

    /// <summary>閉じたパスの内側の塗りつぶし方法を指定する</summary>
    /// <remarks>そのままキャストすればSystem.Windows.Media.FillRuleに適用出来る</remarks>
    public enum FillMode
    {
        /// <summary>交互塗りつぶしモードを指定する</summary>
        Alternate,
        /// <summary>全域塗りつぶしモードを指定する</summary>
        Winding
    }

    /// <summary>オブジェクトのタイプを指定する</summary>
    public enum ObjectType : int
    {
        /// <summary>種類が無い、オブジェクトが無い事を示す</summary>
        None = 0,
        /// <summary>Lineオブジェクトを示す</summary>
        Line = 1,
        /// <summary>長方形オブジェクトを示す</summary>
        Rectangle = 2,
        /// <summary>楕円オブジェクトを示す</summary>
        Ellipse = 4,
        /// <summary>多角形オブジェクトを示す</summary>
        Polygon = 8,
        /// <summary>連続する直線オブジェクトを示す</summary>
        Polyline = 16,
        /// <summary>曲線など複雑な図形を示す</summary>
        Path = 32,
        /// <summary>イメージオブジェクトを示す</summary>
        Image = 64,
        /// <summary>文字列オブジェクトを示す</summary>
        String = 128,
        /// <summary>指定オブジェクトに属さないオブジェクトを示す</summary>
        Rest = 256,
        /// <summary>全種類を示す</summary>
        AllKind = Line | Rectangle | Ellipse | Polygon | Polyline | Path | Image | String | Rest
    }

    /// <summary>階層の深さを表す</summary>
    public enum Hierarchy
    {
        /// <summary>最下層のキャンバスを示す</summary>
        BackgroundCanvas,
        /// <summary>最下層のイメージを示す</summary>
        BackgroundImage,
        /// <summary>中央の層のキャンバスを示す</summary>
        BaseCanvas,
        /// <summary>中央の層のイメージを示す</summary>
        BaseImage,
        /// <summary>最上層のキャンバスを示す</summary>
        RefreshCanvas,
        /// <summary>最上層のイメージを示す</summary>
        RefreshImage
    }

    /// <summary>BaseBrushに入っているブラシの種類を表す</summary>
    public enum BrushType
    {
        /// <summary>HatchBrush</summary>
        HatchBrush,
        /// <summary>ImageBrush</summary>
        ImageBrush,
        /// <summary>SolidColorBrush</summary>
        SolidColorBrush
    }

    /// <summary>イメージの回転の方向と、イメージ反転時の軸を決める</summary>
    public enum RotateFlipType
    {
        /// <summary>回転も反転も行わないことを指定します。</summary>
        RotateNoneFlipNone,
        /// <summary>回転せずに水平方向と垂直方向に反転することを指定します。</summary>
        RotateNoneFlipXY,
        /// <summary>回転せずに水平方向に反転することを指定します。</summary>
        RotateNoneFlipX,
        /// <summary>回転せずに垂直方向に反転することを指定します。</summary>
        RotateNoneFlipY,
        /// <summary>反転せずに 90 度回転することを指定します。</summary>
        Rotate90FlipNone,
        /// <summary>90 度回転してから、水平方向と垂直方向に反転することを指定します。</summary>
        Rotate90FlipXY,
        /// <summary>90 度回転してから、水平方向に反転することを指定します。</summary>
        Rotate90FlipX,
        /// <summary>90 度回転してから、垂直方向に反転することを指定します。</summary>
        Rotate90FlipY,
        /// <summary>180 度回転してから、水平方向と垂直方向に反転することを指定します。</summary>
        Rotate180FlipXY = RotateNoneFlipNone,
        /// <summary>反転せずに 180 度回転することを指定します。</summary>
        Rotate180FlipNone = RotateNoneFlipXY,
        /// <summary>180 度回転してから、垂直方向に反転することを指定します。</summary>
        Rotate180FlipY = RotateNoneFlipX,
        /// <summary>180 度回転してから、水平方向に反転することを指定します。</summary>
        Rotate180FlipX = RotateNoneFlipY,
        /// <summary>270 度回転してから、水平方向と垂直方向に反転することを指定します。</summary>
        Rotate270FlipXY = Rotate90FlipNone,
        /// <summary>反転せずに 270 度回転することを指定します。</summary>
        Rotate270FlipNone = Rotate90FlipXY,
        /// <summary>270 度回転してから、垂直方向に反転することを指定します。</summary>
        Rotate270FlipY = Rotate90FlipX,
        /// <summary>270 度回転してから、水平方向に反転することを指定します。</summary>
        Rotate270FlipX = Rotate90FlipY
    }

    /// <summary>FixPointクラスの固定小数の設定を決める</summary>
    internal enum FixPointConstants
    {
        /// <summary>両方とも固定小数</summary>
        FixBoth,
        /// <summary>Xのみ固定小数</summary>
        FixX,
        /// <summary>Yのみ固定小数</summary>
        FixY,
        /// <summary>両方とも通常</summary>
        NonFix
    }
    #endregion

    #region Penクラス
    /// <summary>.NET FrameworkのPenとほぼ同等なPen</summary>
    public sealed class Pen
    {
        #region フィールド・プロパティ
        private SolidColorBrush BaseBrush;
        private DashStyle DS;
        private DoubleCollection DA;
        private double PW;
        //private int[,] PenShape;
        //private int iWidth;
        //private int Interval;
        //private iPoint Start;

        /// <summary>Penの幅</summary>
        /// <exception cref="System.ArgumentOutOfRangeException">Widthに1.0未満の数を入れようとした場合に発生</exception>
        public double Width
        {
            get { return this.PW; }
            set {
                if (value < 1.0)
                    throw new ArgumentOutOfRangeException("Widthに1.0未満の数を入れることは出来ません。");

                this.PW = value; 
            }
        }

        /// <summary>図形のアウトラインの描画に使用されるダッシュと空白の破線パターンを示す System.Double 値のコレクションを取得または設定します。</summary>
        public DoubleCollection DashArray
        {
            get
            {
                DoubleCollection res = new DoubleCollection();

                foreach(double tmp in this.DA)
                    res.Add(tmp);

                return res;
            }
            set
            {
                this.DA = value;
                this.DS = DashStyle.Custom;
            } 
        }

        /// <summary>破線 (ダッシュ) の端を描画する方法を指定する System.Windows.Media.PenLineCap 列挙値を取得または設定します。</summary>
        public PenLineCap DashCap { get; set; }

        /// <summary>破線パターン内のダッシュの始点間の距離を指定する System.Double を取得または設定します。</summary>
        public double DashOffset { get; set; }

        /// <summary>線の始点にある System.Windows.Media.PenLineCap 列挙値を取得または設定します。</summary>
        public PenLineCap StartCap { get; set; }

        /// <summary>線の終点にある System.Windows.Media.PenLineCap 列挙値を取得または設定します。</summary>
        public PenLineCap EndCap { get; set; }

        /// <summary>ダッシュと空白の破線パターンの既定値を示す</summary>
        public DashStyle DashStyle
        {
            get { return this.DS; }
            set
            {
                this.DS = value;

                switch (value)
                {
                    case DashStyle.Solid:
                        this.DA.Clear();
                        break;

                    case DashStyle.Dash:
                        this.DA.Clear();
                        this.DA.Add(3.0);
                        this.DA.Add(1.0);
                        break;

                    case DashStyle.Dot:
                        this.DA.Clear();
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        break;

                    case DashStyle.DashDot:
                        this.DA.Clear();
                        this.DA.Add(3.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        break;

                    case DashStyle.DashDotDot:
                        this.DA.Clear();
                        this.DA.Add(3.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        this.DA.Add(1.0);
                        break;

                    case DashStyle.Custom:
                        break;
                }
            }
        }

        /// <summary>Penの色を取得または設定します。</summary>
        public Color Color
        {
            get { return this.BaseBrush.Color; }
            set { this.BaseBrush.Color = value; }
        }

        /// <summary>PenのベースとなるSolidColorBrushを取得または設定します。</summary>
        public SolidColorBrush Brush
        {
            get { return new SolidColorBrush(this.Color); }

            set { this.BaseBrush = value; }
        }
        #endregion

        #region コンストラクタ・キャストのオーバーロード
        /// <summary>ベースのブラシを返す</summary>
        /// <param name="Obj">対象のPen</param>
        /// <returns>PenのベースBrush</returns>
        public static implicit operator Brush(Pen Obj)
        {
            return Obj.Brush;
        }

        /// <summary>ベースのブラシを返す</summary>
        /// <param name="Obj">対象のPen</param>
        /// <returns>PenのベースBrush</returns>
        public static implicit operator SolidColorBrush(Pen Obj)
        {
            return Obj.Brush;
        }

        /// <summary>現在のインスタンスを複製して返す</summary>
        /// <returns>複製したオブジェクト</returns>
        public object Clone()
        {
            Pen tmp = new Pen(this.Brush, this.Width);
            tmp.DashArray = this.DashArray;
            tmp.DashCap = this.DashCap;
            tmp.DashOffset = this.DashOffset;
            tmp.DashStyle = this.DashStyle;
            tmp.EndCap = this.EndCap;
            tmp.StartCap = this.StartCap;

            return tmp;
        }

        private void CommonInit()
        {
            this.DA = new DoubleCollection();
            this.DashCap = PenLineCap.Flat;
            this.DashOffset = 0.0;
            this.DS = DashStyle.Solid;
            this.EndCap = PenLineCap.Flat;
            this.StartCap = PenLineCap.Flat;
            //CreateShape();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Color">Penの色を指定</param>
        public Pen(Color Color)
        {
            this.Width = 1.0;
            this.BaseBrush = new SolidColorBrush(Color);
            CommonInit();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Color">Penの色</param>
        /// <param name="Width">Penの幅</param>
        public Pen(Color Color, double Width)
        {
            this.Width = Width;
            this.BaseBrush = new SolidColorBrush(Color);
            CommonInit();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Brush">Penのプロパティを決定するSolidColorBrush</param>
        public Pen(SolidColorBrush Brush)
        {
            this.Width = 1.0;
            this.BaseBrush = Brush;
            CommonInit();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Brush">Penのプロパティを決定するSolidColorBrush</param>
        /// <param name="Width">Penの幅</param>
        public Pen(SolidColorBrush Brush, double Width)
        {
            this.Width = Width;
            this.BaseBrush = Brush;
            CommonInit();
        }

        //private void CreateShape()
        //{
        //    int TC = this.Color.ToArgb();
        //    this.iWidth = (int)Math.Ceiling(this.Width);

        //    this.Interval = 0;

        //    for (int i = 0; i < this.DA.Count; i++)
        //        this.Interval += (int)(iWidth * DA[i]);

        //    this.PenShape = new int[this.iWidth, this.Interval];

        //    int cnt = 0;
        //    int tmp=0;

        //    for (int i = 0; i < this.Interval; i++)
        //    {
        //        if ((int)(iWidth * DA[cnt]) + tmp < i)
        //        {
        //            tmp = (int)(iWidth * DA[cnt]);
        //            cnt++;
        //        }

        //        for (int j = 0; j < this.iWidth; j++)
        //            this.PenShape[j, i] = ((cnt & 1) == 0 ? TC : 0);
        //    }
        //}

        ///// <summary>パターンを求めるために必要なパラメータを設定する</summary>
        ///// <param name="X">始点X</param>
        ///// <param name="Y">終点Y</param>
        ///// <param name="theta">描く線の傾きを表すrad角度</param>
        //public void SetParameter(double X, double Y,double theta)
        //{
        //    this.Start = new iPoint((int)X, (int)Y);
        //}

        ///// <summary>Penの形状を指定座標で得る</summary>
        ///// <param name="X">指定座標X</param>
        ///// <param name="Y">指定座標Y</param>
        ///// <returns>ピクセル情報(ARGB形式)</returns>
        //public int GetPenShape(int X, int Y)
        //{
        //    return this.PenShape[X, Y % this.Interval];
        //}
        #endregion
    }
    #endregion

    #region Pensクラス
    /// <summary>.NET FrameworkのPensとほぼ同等なPens</summary>
    /// <remarks>注意
    /// <para>このクラスのPenに対して書き込みを行わないでください。</para>
    /// <para>書き込みを行ってしまった場合その色が次から使えなくなってしまいます。</para></remarks>
    public static class Pens
    {
        #region 無効メソッド
        /// <summary>使用は出来ますが、エディット内から参照は出来ません</summary>
        /// <param name="objA">比較するオブジェクトA</param>
        /// <param name="objB">比較するオブジェクトB</param>
        /// <returns>オブジェクトが等しかったかどうか</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return object.Equals(objA, objB);
        }

        /// <summary>使用は出来ますが、エディット内から参照は出来ません</summary>
        /// <param name="objA">比較するオブジェクトA</param>
        /// <param name="objB">比較するオブジェクトB</param>
        /// <returns>オブジェクトが等しかったかどうか</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return object.ReferenceEquals(objA, objB);
        }
        #endregion

        #region 識別列挙体
        private enum CColor
        {
            AliceBlue,
            AntiqueWhite,
            Aqua,
            Aquamarine,
            Azure,
            Beige,
            Bisque,
            Black,
            BlanchedAlmond,
            Blue,
            BlueViolet,
            Brown,
            BurlyWood,
            CadetBlue,
            Chartreuse,
            Chocolate,
            Coral,
            CornflowerBlue,
            Cornsilk,
            Crimson,
            Cyan,
            DarkBlue,
            DarkCyan,
            DarkGoldenrod,
            DarkGray,
            DarkGreen,
            DarkKhaki,
            DarkMagenta,
            DarkOliveGreen,
            DarkOrange,
            DarkOrchid,
            DarkRed,
            DarkSalmon,
            DarkSeaGreen,
            DarkSlateBlue,
            DarkSlateGray,
            DarkTurquoise,
            DarkViolet,
            DeepPink,
            DeepSkyBlue,
            DimGray,
            DodgerBlue,
            Firebrick,
            FloralWhite,
            ForestGreen,
            Fuchsia,
            Gainsboro,
            GhostWhite,
            Gold,
            Goldenrod,
            Gray,
            Green,
            GreenYellow,
            Honeydew,
            HotPink,
            IndianRed,
            Indigo,
            Ivory,
            Khaki,
            Lavender,
            LavenderBlush,
            LawnGreen,
            LemonChiffon,
            LightBlue,
            LightCoral,
            LightCyan,
            LightGoldenrodYellow,
            LightGray,
            LightGreen,
            LightPink,
            LightSalmon,
            LightSeaGreen,
            LightSkyBlue,
            LightSlateGray,
            LightSteelBlue,
            LightYellow,
            Lime,
            LimeGreen,
            Linen,
            Magenta,
            Maroon,
            MediumAquamarine,
            MediumBlue,
            MediumOrchid,
            MediumPurple,
            MediumSeaGreen,
            MediumSlateBlue,
            MediumSpringGreen,
            MediumTurquoise,
            MediumVioletRed,
            MidnightBlue,
            MintCream,
            MistyRose,
            Moccasin,
            NavajoWhite,
            Navy,
            OldLace,
            Olive,
            OliveDrab,
            Orange,
            OrangeRed,
            Orchid,
            PaleGoldenrod,
            PaleGreen,
            PaleTurquoise,
            PaleVioletRed,
            PapayaWhip,
            PeachPuff,
            Peru,
            Pink,
            Plum,
            PowderBlue,
            Purple,
            Red,
            RosyBrown,
            RoyalBlue,
            SaddleBrown,
            Salmon,
            SandyBrown,
            SeaGreen,
            SeaShell,
            Sienna,
            Silver,
            SkyBlue,
            SlateBlue,
            SlateGray,
            Snow,
            SpringGreen,
            SteelBlue,
            Tan,
            Teal,
            Thistle,
            Tomato,
            Transparent,
            Turquoise,
            Violet,
            Wheat,
            White,
            WhiteSmoke,
            Yellow,
            YellowGreen
        }
        #endregion

        #region 既定色を表すためのフィールドとメソッド
        private static Pen[] PenConstants;

        private static Pen GetPen(CColor Index)
        {
            if (PenConstants == null)
                PenConstants = new Pen[(int)CColor.YellowGreen + 1];

            if (PenConstants[(int)Index] == null)
            {
                Color tcolor = default(Color);

                switch (Index)
                {
                    case CColor.AliceBlue:
                        tcolor = Color.FromArgb(0xFF, 0xF0, 0xF8, 0xFF);
                        break;

                    case CColor.AntiqueWhite:
                        tcolor = Color.FromArgb(0xFF, 0xFA, 0xEB, 0xD7);
                        break;

                    case CColor.Aqua:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xFF, 0xFF);
                        break;

                    case CColor.Aquamarine:
                        tcolor = Color.FromArgb(0xFF, 0x7F, 0xFF, 0xD4);
                        break;

                    case CColor.Azure:
                        tcolor = Color.FromArgb(0xFF, 0xF0, 0xFF, 0xFF);
                        break;

                    case CColor.Beige:
                        tcolor = Color.FromArgb(0xFF, 0xF5, 0xF5, 0xDC);
                        break;

                    case CColor.Bisque:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xE4, 0xC4);
                        break;

                    case CColor.Black:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x00, 0x00);
                        break;

                    case CColor.BlanchedAlmond:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xEB, 0xCD);
                        break;

                    case CColor.Blue:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x00, 0xFF);
                        break;

                    case CColor.BlueViolet:
                        tcolor = Color.FromArgb(0xFF, 0x8A, 0x2B, 0xE2);
                        break;

                    case CColor.Brown:
                        tcolor = Color.FromArgb(0xFF, 0xA5, 0x2A, 0x2A);
                        break;

                    case CColor.BurlyWood:
                        tcolor = Color.FromArgb(0xFF, 0xDE, 0xB8, 0x87);
                        break;

                    case CColor.CadetBlue:
                        tcolor = Color.FromArgb(0xFF, 0x5F, 0x9E, 0xA0);
                        break;

                    case CColor.Chartreuse:
                        tcolor = Color.FromArgb(0xFF, 0x7F, 0xFF, 0x00);
                        break;

                    case CColor.Chocolate:
                        tcolor = Color.FromArgb(0xFF, 0xD2, 0x69, 0x1E);
                        break;

                    case CColor.Coral:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x7F, 0x50);
                        break;

                    case CColor.CornflowerBlue:
                        tcolor = Color.FromArgb(0xFF, 0x64, 0x95, 0xED);
                        break;

                    case CColor.Cornsilk:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xF8, 0xDC);
                        break;

                    case CColor.Crimson:
                        tcolor = Color.FromArgb(0xFF, 0xDC, 0x14, 0x3C);
                        break;

                    case CColor.Cyan:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xFF, 0xFF);
                        break;

                    case CColor.DarkBlue:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x00, 0x8B);
                        break;

                    case CColor.DarkCyan:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x8B, 0x8B);
                        break;

                    case CColor.DarkGoldenrod:
                        tcolor = Color.FromArgb(0xFF, 0xB8, 0x86, 0x0B);
                        break;

                    case CColor.DarkGray:
                        tcolor = Color.FromArgb(0xFF, 0xA9, 0xA9, 0xA9);
                        break;

                    case CColor.DarkGreen:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x64, 0x00);
                        break;

                    case CColor.DarkKhaki:
                        tcolor = Color.FromArgb(0xFF, 0xBD, 0xB7, 0x6B);
                        break;

                    case CColor.DarkMagenta:
                        tcolor = Color.FromArgb(0xFF, 0x8B, 0x00, 0x8B);
                        break;

                    case CColor.DarkOliveGreen:
                        tcolor = Color.FromArgb(0xFF, 0x55, 0x6B, 0x2F);
                        break;

                    case CColor.DarkOrange:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x8C, 0x00);
                        break;

                    case CColor.DarkOrchid:
                        tcolor = Color.FromArgb(0xFF, 0x99, 0x32, 0xCC);
                        break;

                    case CColor.DarkRed:
                        tcolor = Color.FromArgb(0xFF, 0x8B, 0x00, 0x00);
                        break;

                    case CColor.DarkSalmon:
                        tcolor = Color.FromArgb(0xFF, 0xE9, 0x96, 0x7A);
                        break;

                    case CColor.DarkSeaGreen:
                        tcolor = Color.FromArgb(0xFF, 0x8F, 0xBC, 0x8F);
                        break;

                    case CColor.DarkSlateBlue:
                        tcolor = Color.FromArgb(0xFF, 0x48, 0x3D, 0x8B);
                        break;

                    case CColor.DarkSlateGray:
                        tcolor = Color.FromArgb(0xFF, 0x2F, 0x4F, 0x4F);
                        break;

                    case CColor.DarkTurquoise:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xCE, 0xD1);
                        break;

                    case CColor.DarkViolet:
                        tcolor = Color.FromArgb(0xFF, 0x94, 0x00, 0xD3);
                        break;

                    case CColor.DeepPink:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x14, 0x93);
                        break;

                    case CColor.DeepSkyBlue:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xBF, 0xFF);
                        break;

                    case CColor.DimGray:
                        tcolor = Color.FromArgb(0xFF, 0x69, 0x69, 0x69);
                        break;

                    case CColor.DodgerBlue:
                        tcolor = Color.FromArgb(0xFF, 0x1E, 0x90, 0xFF);
                        break;

                    case CColor.Firebrick:
                        tcolor = Color.FromArgb(0xFF, 0xB2, 0x22, 0x22);
                        break;

                    case CColor.FloralWhite:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFA, 0xF0);
                        break;

                    case CColor.ForestGreen:
                        tcolor = Color.FromArgb(0xFF, 0x22, 0x8B, 0x22);
                        break;

                    case CColor.Fuchsia:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x00, 0xFF);
                        break;

                    case CColor.Gainsboro:
                        tcolor = Color.FromArgb(0xFF, 0xDC, 0xDC, 0xDC);
                        break;

                    case CColor.GhostWhite:
                        tcolor = Color.FromArgb(0xFF, 0xF8, 0xF8, 0xFF);
                        break;

                    case CColor.Gold:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xD7, 0x00);
                        break;

                    case CColor.Goldenrod:
                        tcolor = Color.FromArgb(0xFF, 0xDA, 0xA5, 0x20);
                        break;

                    case CColor.Gray:
                        tcolor = Color.FromArgb(0xFF, 0x80, 0x80, 0x80);
                        break;

                    case CColor.Green:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x80, 0x00);
                        break;

                    case CColor.GreenYellow:
                        tcolor = Color.FromArgb(0xFF, 0xAD, 0xFF, 0x2F);
                        break;

                    case CColor.Honeydew:
                        tcolor = Color.FromArgb(0xFF, 0xF0, 0xFF, 0xF0);
                        break;

                    case CColor.HotPink:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x69, 0xB4);
                        break;

                    case CColor.IndianRed:
                        tcolor = Color.FromArgb(0xFF, 0xCD, 0x5C, 0x5C);
                        break;

                    case CColor.Indigo:
                        tcolor = Color.FromArgb(0xFF, 0x4B, 0x00, 0x82);
                        break;

                    case CColor.Ivory:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xF0);
                        break;

                    case CColor.Khaki:
                        tcolor = Color.FromArgb(0xFF, 0xF0, 0xE6, 0x8C);
                        break;

                    case CColor.Lavender:
                        tcolor = Color.FromArgb(0xFF, 0xE6, 0xE6, 0xFA);
                        break;

                    case CColor.LavenderBlush:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xF0, 0xF5);
                        break;

                    case CColor.LawnGreen:
                        tcolor = Color.FromArgb(0xFF, 0x7C, 0xFC, 0x00);
                        break;

                    case CColor.LemonChiffon:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFA, 0xCD);
                        break;

                    case CColor.LightBlue:
                        tcolor = Color.FromArgb(0xFF, 0xAD, 0xD8, 0xE6);
                        break;

                    case CColor.LightCoral:
                        tcolor = Color.FromArgb(0xFF, 0xF0, 0x80, 0x80);
                        break;

                    case CColor.LightCyan:
                        tcolor = Color.FromArgb(0xFF, 0xE0, 0xFF, 0xFF);
                        break;

                    case CColor.LightGoldenrodYellow:
                        tcolor = Color.FromArgb(0xFF, 0xFA, 0xFA, 0xD2);
                        break;

                    case CColor.LightGray:
                        tcolor = Color.FromArgb(0xFF, 0xD3, 0xD3, 0xD3);
                        break;

                    case CColor.LightGreen:
                        tcolor = Color.FromArgb(0xFF, 0x90, 0xEE, 0x90);
                        break;

                    case CColor.LightPink:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xB6, 0xC1);
                        break;

                    case CColor.LightSalmon:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xA0, 0x7A);
                        break;

                    case CColor.LightSeaGreen:
                        tcolor = Color.FromArgb(0xFF, 0x20, 0xB2, 0xAA);
                        break;

                    case CColor.LightSkyBlue:
                        tcolor = Color.FromArgb(0xFF, 0x87, 0xCE, 0xFA);
                        break;

                    case CColor.LightSlateGray:
                        tcolor = Color.FromArgb(0xFF, 0x77, 0x88, 0x99);
                        break;

                    case CColor.LightSteelBlue:
                        tcolor = Color.FromArgb(0xFF, 0xB0, 0xC4, 0xDE);
                        break;

                    case CColor.LightYellow:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xE0);
                        break;

                    case CColor.Lime:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xFF, 0x00);
                        break;

                    case CColor.LimeGreen:
                        tcolor = Color.FromArgb(0xFF, 0x32, 0xCD, 0x32);
                        break;

                    case CColor.Linen:
                        tcolor = Color.FromArgb(0xFF, 0xFA, 0xF0, 0xE6);
                        break;

                    case CColor.Magenta:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x00, 0xFF);
                        break;

                    case CColor.Maroon:
                        tcolor = Color.FromArgb(0xFF, 0x80, 0x00, 0x00);
                        break;

                    case CColor.MediumAquamarine:
                        tcolor = Color.FromArgb(0xFF, 0x66, 0xCD, 0xAA);
                        break;

                    case CColor.MediumBlue:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x00, 0xCD);
                        break;

                    case CColor.MediumOrchid:
                        tcolor = Color.FromArgb(0xFF, 0xBA, 0x55, 0xD3);
                        break;

                    case CColor.MediumPurple:
                        tcolor = Color.FromArgb(0xFF, 0x93, 0x70, 0xDB);
                        break;

                    case CColor.MediumSeaGreen:
                        tcolor = Color.FromArgb(0xFF, 0x3C, 0xB3, 0x71);
                        break;

                    case CColor.MediumSlateBlue:
                        tcolor = Color.FromArgb(0xFF, 0x7B, 0x68, 0xEE);
                        break;

                    case CColor.MediumSpringGreen:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xFA, 0x9A);
                        break;

                    case CColor.MediumTurquoise:
                        tcolor = Color.FromArgb(0xFF, 0x48, 0xD1, 0xCC);
                        break;

                    case CColor.MediumVioletRed:
                        tcolor = Color.FromArgb(0xFF, 0xC7, 0x15, 0x85);
                        break;

                    case CColor.MidnightBlue:
                        tcolor = Color.FromArgb(0xFF, 0x19, 0x19, 0x70);
                        break;

                    case CColor.MintCream:
                        tcolor = Color.FromArgb(0xFF, 0xF5, 0xFF, 0xFA);
                        break;

                    case CColor.MistyRose:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xE4, 0xE1);
                        break;

                    case CColor.Moccasin:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xE4, 0xB5);
                        break;

                    case CColor.NavajoWhite:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xDE, 0xAD);
                        break;

                    case CColor.Navy:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x00, 0x80);
                        break;

                    case CColor.OldLace:
                        tcolor = Color.FromArgb(0xFF, 0xFD, 0xF5, 0xE6);
                        break;

                    case CColor.Olive:
                        tcolor = Color.FromArgb(0xFF, 0x80, 0x80, 0x00);
                        break;

                    case CColor.OliveDrab:
                        tcolor = Color.FromArgb(0xFF, 0x6B, 0x8E, 0x23);
                        break;

                    case CColor.Orange:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xA5, 0x00);
                        break;

                    case CColor.OrangeRed:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x45, 0x00);
                        break;

                    case CColor.Orchid:
                        tcolor = Color.FromArgb(0xFF, 0xDA, 0x70, 0xD6);
                        break;

                    case CColor.PaleGoldenrod:
                        tcolor = Color.FromArgb(0xFF, 0xEE, 0xE8, 0xAA);
                        break;

                    case CColor.PaleGreen:
                        tcolor = Color.FromArgb(0xFF, 0x98, 0xFB, 0x98);
                        break;

                    case CColor.PaleTurquoise:
                        tcolor = Color.FromArgb(0xFF, 0xAF, 0xEE, 0xEE);
                        break;

                    case CColor.PaleVioletRed:
                        tcolor = Color.FromArgb(0xFF, 0xDB, 0x70, 0x93);
                        break;

                    case CColor.PapayaWhip:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xEF, 0xD5);
                        break;

                    case CColor.PeachPuff:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xDA, 0xB9);
                        break;

                    case CColor.Peru:
                        tcolor = Color.FromArgb(0xFF, 0xCD, 0x85, 0x3F);
                        break;

                    case CColor.Pink:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xC0, 0xCB);
                        break;

                    case CColor.Plum:
                        tcolor = Color.FromArgb(0xFF, 0xDD, 0xA0, 0xDD);
                        break;

                    case CColor.PowderBlue:
                        tcolor = Color.FromArgb(0xFF, 0xB0, 0xE0, 0xE6);
                        break;

                    case CColor.Purple:
                        tcolor = Color.FromArgb(0xFF, 0x80, 0x00, 0x80);
                        break;

                    case CColor.Red:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x00, 0x00);
                        break;

                    case CColor.RosyBrown:
                        tcolor = Color.FromArgb(0xFF, 0xBC, 0x8F, 0x8F);
                        break;

                    case CColor.RoyalBlue:
                        tcolor = Color.FromArgb(0xFF, 0x41, 0x69, 0xE1);
                        break;

                    case CColor.SaddleBrown:
                        tcolor = Color.FromArgb(0xFF, 0x8B, 0x45, 0x13);
                        break;

                    case CColor.Salmon:
                        tcolor = Color.FromArgb(0xFF, 0xFA, 0x80, 0x72);
                        break;

                    case CColor.SandyBrown:
                        tcolor = Color.FromArgb(0xFF, 0xF4, 0xA4, 0x60);
                        break;

                    case CColor.SeaGreen:
                        tcolor = Color.FromArgb(0xFF, 0x2E, 0x8B, 0x57);
                        break;

                    case CColor.SeaShell:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xF5, 0xEE);
                        break;

                    case CColor.Sienna:
                        tcolor = Color.FromArgb(0xFF, 0xA0, 0x52, 0x2D);
                        break;

                    case CColor.Silver:
                        tcolor = Color.FromArgb(0xFF, 0xC0, 0xC0, 0xC0);
                        break;

                    case CColor.SkyBlue:
                        tcolor = Color.FromArgb(0xFF, 0x87, 0xCE, 0xEB);
                        break;

                    case CColor.SlateBlue:
                        tcolor = Color.FromArgb(0xFF, 0x6A, 0x5A, 0xCD);
                        break;

                    case CColor.SlateGray:
                        tcolor = Color.FromArgb(0xFF, 0x70, 0x80, 0x90);
                        break;

                    case CColor.Snow:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFA, 0xFA);
                        break;

                    case CColor.SpringGreen:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0xFF, 0x7F);
                        break;

                    case CColor.SteelBlue:
                        tcolor = Color.FromArgb(0xFF, 0x46, 0x82, 0xB4);
                        break;

                    case CColor.Tan:
                        tcolor = Color.FromArgb(0xFF, 0xD2, 0xB4, 0x8C);
                        break;

                    case CColor.Teal:
                        tcolor = Color.FromArgb(0xFF, 0x00, 0x80, 0x80);
                        break;

                    case CColor.Thistle:
                        tcolor = Color.FromArgb(0xFF, 0xD8, 0xBF, 0xD8);
                        break;

                    case CColor.Tomato:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0x63, 0x47);
                        break;

                    case CColor.Transparent:
                        tcolor = Color.FromArgb(0x00, 0x00, 0x00, 0x00);
                        break;

                    case CColor.Turquoise:
                        tcolor = Color.FromArgb(0xFF, 0x40, 0xE0, 0xD0);
                        break;

                    case CColor.Violet:
                        tcolor = Color.FromArgb(0xFF, 0xEE, 0x82, 0xEE);
                        break;

                    case CColor.Wheat:
                        tcolor = Color.FromArgb(0xFF, 0xF5, 0xDE, 0xB3);
                        break;

                    case CColor.White:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
                        break;

                    case CColor.WhiteSmoke:
                        tcolor = Color.FromArgb(0xFF, 0xF5, 0xF5, 0xF5);
                        break;

                    case CColor.Yellow:
                        tcolor = Color.FromArgb(0xFF, 0xFF, 0xFF, 0x00);
                        break;

                    case CColor.YellowGreen:
                        tcolor = Color.FromArgb(0xFF, 0x9A, 0xCD, 0x32);
                        break;
                }

                PenConstants[(int)Index] = new Pen(tcolor);
            }

            return PenConstants[(int)Index];
        }
        #endregion

        #region 既定色を表すプロパティ
        /// <summary>幅 1、ARGB 値が #FFF0F8FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen AliceBlue
        {
            get { return GetPen(CColor.AliceBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFFAEBD7 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen AntiqueWhite
        {
            get { return GetPen(CColor.AntiqueWhite); }
        }

        /// <summary>幅 1、ARGB 値が #FF00FFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Aqua
        {
            get { return GetPen(CColor.Aqua); }
        }

        /// <summary>幅 1、ARGB 値が #FF7FFFD4 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Aquamarine
        {
            get { return GetPen(CColor.Aquamarine); }
        }

        /// <summary>幅 1、ARGB 値が #FFF0FFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Azure
        {
            get { return GetPen(CColor.Azure); }
        }

        /// <summary>幅 1、ARGB 値が #FFF5F5DC のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Beige
        {
            get { return GetPen(CColor.Beige); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFE4C4 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Bisque
        {
            get { return GetPen(CColor.Bisque); }
        }

        /// <summary>幅 1、ARGB 値が #FF000000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Black
        {
            get { return GetPen(CColor.Black); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFEBCD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen BlanchedAlmond
        {
            get { return GetPen(CColor.BlanchedAlmond); }
        }

        /// <summary>幅 1、ARGB 値が #FF0000FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Blue
        {
            get { return GetPen(CColor.Blue); }
        }

        /// <summary>幅 1、ARGB 値が #FF8A2BE2 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen BlueViolet
        {
            get { return GetPen(CColor.BlueViolet); }
        }

        /// <summary>幅 1、ARGB 値が #FFA52A2A のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Brown
        {
            get { return GetPen(CColor.Brown); }
        }

        /// <summary>幅 1、ARGB 値が #FFDEB887 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen BurlyWood
        {
            get { return GetPen(CColor.BurlyWood); }
        }

        /// <summary>幅 1、ARGB 値が #FF5F9EA0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen CadetBlue
        {
            get { return GetPen(CColor.CadetBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF7FFF00 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Chartreuse
        {
            get { return GetPen(CColor.Chartreuse); }
        }

        /// <summary>幅 1、ARGB 値が #FFD2691E のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Chocolate
        {
            get { return GetPen(CColor.Chocolate); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF7F50 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Coral
        {
            get { return GetPen(CColor.Coral); }
        }

        /// <summary>幅 1、ARGB 値が #FF6495ED のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen CornflowerBlue
        {
            get { return GetPen(CColor.CornflowerBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFF8DC のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Cornsilk
        {
            get { return GetPen(CColor.Cornsilk); }
        }

        /// <summary>幅 1、ARGB 値が #FFDC143C のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Crimson
        {
            get { return GetPen(CColor.Crimson); }
        }

        /// <summary>幅 1、ARGB 値が #FF00FFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Cyan
        {
            get { return GetPen(CColor.Cyan); }
        }

        /// <summary>幅 1、ARGB 値が #FF00008B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkBlue
        {
            get { return GetPen(CColor.DarkBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF008B8B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkCyan
        {
            get { return GetPen(CColor.DarkCyan); }
        }

        /// <summary>幅 1、ARGB 値が #FFB8860B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkGoldenrod
        {
            get { return GetPen(CColor.DarkGoldenrod); }
        }

        /// <summary>幅 1、ARGB 値が #FFA9A9A9 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkGray
        {
            get { return GetPen(CColor.DarkGray); }
        }

        /// <summary>幅 1、ARGB 値が #FF006400 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkGreen
        {
            get { return GetPen(CColor.DarkGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFBDB76B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkKhaki
        {
            get { return GetPen(CColor.DarkKhaki); }
        }

        /// <summary>幅 1、ARGB 値が #FF8B008B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkMagenta
        {
            get { return GetPen(CColor.DarkMagenta); }
        }

        /// <summary>幅 1、ARGB 値が #FF556B2F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkOliveGreen
        {
            get { return GetPen(CColor.DarkOliveGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF8C00 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkOrange
        {
            get { return GetPen(CColor.DarkOrange); }
        }

        /// <summary>幅 1、ARGB 値が #FF9932CC のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkOrchid
        {
            get { return GetPen(CColor.DarkOrchid); }
        }

        /// <summary>幅 1、ARGB 値が #FF8B0000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkRed
        {
            get { return GetPen(CColor.DarkRed); }
        }

        /// <summary>幅 1、ARGB 値が #FFE9967A のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkSalmon
        {
            get { return GetPen(CColor.DarkSalmon); }
        }

        /// <summary>幅 1、ARGB 値が #FF8FBC8F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkSeaGreen
        {
            get { return GetPen(CColor.DarkSeaGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FF483D8B のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkSlateBlue
        {
            get { return GetPen(CColor.DarkSlateBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF2F4F4F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkSlateGray
        {
            get { return GetPen(CColor.DarkSlateGray); }
        }

        /// <summary>幅 1、ARGB 値が #FF00CED1 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkTurquoise
        {
            get { return GetPen(CColor.DarkTurquoise); }
        }

        /// <summary>幅 1、ARGB 値が #FF9400D3 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DarkViolet
        {
            get { return GetPen(CColor.DarkViolet); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF1493 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DeepPink
        {
            get { return GetPen(CColor.DeepPink); }
        }

        /// <summary>幅 1、ARGB 値が #FF00BFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DeepSkyBlue
        {
            get { return GetPen(CColor.DeepSkyBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF696969 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DimGray
        {
            get { return GetPen(CColor.DimGray); }
        }

        /// <summary>幅 1、ARGB 値が #FF1E90FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen DodgerBlue
        {
            get { return GetPen(CColor.DodgerBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFB22222 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Firebrick
        {
            get { return GetPen(CColor.Firebrick); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFAF0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen FloralWhite
        {
            get { return GetPen(CColor.FloralWhite); }
        }

        /// <summary>幅 1、ARGB 値が #FF228B22 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen ForestGreen
        {
            get { return GetPen(CColor.ForestGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF00FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Fuchsia
        {
            get { return GetPen(CColor.Fuchsia); }
        }

        /// <summary>幅 1、ARGB 値が #FFDCDCDC のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Gainsboro
        {
            get { return GetPen(CColor.Gainsboro); }
        }

        /// <summary>幅 1、ARGB 値が #FFF8F8FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen GhostWhite
        {
            get { return GetPen(CColor.GhostWhite); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFD700 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Gold
        {
            get { return GetPen(CColor.Gold); }
        }

        /// <summary>幅 1、ARGB 値が #FFDAA520 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Goldenrod
        {
            get { return GetPen(CColor.Goldenrod); }
        }

        /// <summary>幅 1、ARGB 値が #FF808080 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Gray
        {
            get { return GetPen(CColor.Gray); }
        }

        /// <summary>幅 1、ARGB 値が #FF008000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Green
        {
            get { return GetPen(CColor.Green); }
        }

        /// <summary>幅 1、ARGB 値が #FFADFF2F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen GreenYellow
        {
            get { return GetPen(CColor.GreenYellow); }
        }

        /// <summary>幅 1、ARGB 値が #FFF0FFF0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Honeydew
        {
            get { return GetPen(CColor.Honeydew); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF69B4 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen HotPink
        {
            get { return GetPen(CColor.HotPink); }
        }

        /// <summary>幅 1、ARGB 値が #FFCD5C5C のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen IndianRed
        {
            get { return GetPen(CColor.IndianRed); }
        }

        /// <summary>幅 1、ARGB 値が #FF4B0082 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Indigo
        {
            get { return GetPen(CColor.Indigo); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFFF0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Ivory
        {
            get { return GetPen(CColor.Ivory); }
        }

        /// <summary>幅 1、ARGB 値が #FFF0E68C のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Khaki
        {
            get { return GetPen(CColor.Khaki); }
        }

        /// <summary>幅 1、ARGB 値が #FFE6E6FA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Lavender
        {
            get { return GetPen(CColor.Lavender); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFF0F5 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LavenderBlush
        {
            get { return GetPen(CColor.LavenderBlush); }
        }

        /// <summary>幅 1、ARGB 値が #FF7CFC00 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LawnGreen
        {
            get { return GetPen(CColor.LawnGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFACD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LemonChiffon
        {
            get { return GetPen(CColor.LemonChiffon); }
        }

        /// <summary>幅 1、ARGB 値が #FFADD8E6 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightBlue
        {
            get { return GetPen(CColor.LightBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFF08080 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightCoral
        {
            get { return GetPen(CColor.LightCoral); }
        }

        /// <summary>幅 1、ARGB 値が #FFE0FFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightCyan
        {
            get { return GetPen(CColor.LightCyan); }
        }

        /// <summary>幅 1、ARGB 値が #FFFAFAD2 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightGoldenrodYellow
        {
            get { return GetPen(CColor.LightGoldenrodYellow); }
        }

        /// <summary>幅 1、ARGB 値が #FFD3D3D3 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightGray
        {
            get { return GetPen(CColor.LightGray); }
        }

        /// <summary>幅 1、ARGB 値が #FF90EE90 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightGreen
        {
            get { return GetPen(CColor.LightGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFB6C1 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightPink
        {
            get { return GetPen(CColor.LightPink); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFA07A のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightSalmon
        {
            get { return GetPen(CColor.LightSalmon); }
        }

        /// <summary>幅 1、ARGB 値が #FF20B2AA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightSeaGreen
        {
            get { return GetPen(CColor.LightSeaGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FF87CEFA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightSkyBlue
        {
            get { return GetPen(CColor.LightSkyBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF778899 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightSlateGray
        {
            get { return GetPen(CColor.LightSlateGray); }
        }

        /// <summary>幅 1、ARGB 値が #FFB0C4DE のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightSteelBlue
        {
            get { return GetPen(CColor.LightSteelBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFFE0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LightYellow
        {
            get { return GetPen(CColor.LightYellow); }
        }

        /// <summary>幅 1、ARGB 値が #FF00FF00 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Lime
        {
            get { return GetPen(CColor.Lime); }
        }

        /// <summary>幅 1、ARGB 値が #FF32CD32 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen LimeGreen
        {
            get { return GetPen(CColor.LimeGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFAF0E6 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Linen
        {
            get { return GetPen(CColor.Linen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF00FF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Magenta
        {
            get { return GetPen(CColor.Magenta); }
        }

        /// <summary>幅 1、ARGB 値が #FF800000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Maroon
        {
            get { return GetPen(CColor.Maroon); }
        }

        /// <summary>幅 1、ARGB 値が #FF66CDAA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumAquamarine
        {
            get { return GetPen(CColor.MediumAquamarine); }
        }

        /// <summary>幅 1、ARGB 値が #FF0000CD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumBlue
        {
            get { return GetPen(CColor.MediumBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFBA55D3 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumOrchid
        {
            get { return GetPen(CColor.MediumOrchid); }
        }

        /// <summary>幅 1、ARGB 値が #FF9370DB のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumPurple
        {
            get { return GetPen(CColor.MediumPurple); }
        }

        /// <summary>幅 1、ARGB 値が #FF3CB371 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumSeaGreen
        {
            get { return GetPen(CColor.MediumSeaGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FF7B68EE のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumSlateBlue
        {
            get { return GetPen(CColor.MediumSlateBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF00FA9A のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumSpringGreen
        {
            get { return GetPen(CColor.MediumSpringGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FF48D1CC のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumTurquoise
        {
            get { return GetPen(CColor.MediumTurquoise); }
        }

        /// <summary>幅 1、ARGB 値が #FFC71585 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MediumVioletRed
        {
            get { return GetPen(CColor.MediumVioletRed); }
        }

        /// <summary>幅 1、ARGB 値が #FF191970 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MidnightBlue
        {
            get { return GetPen(CColor.MidnightBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFF5FFFA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MintCream
        {
            get { return GetPen(CColor.MintCream); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFE4E1 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen MistyRose
        {
            get { return GetPen(CColor.MistyRose); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFE4B5 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Moccasin
        {
            get { return GetPen(CColor.Moccasin); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFDEAD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen NavajoWhite
        {
            get { return GetPen(CColor.NavajoWhite); }
        }

        /// <summary>幅 1、ARGB 値が #FF000080 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Navy
        {
            get { return GetPen(CColor.Navy); }
        }

        /// <summary>幅 1、ARGB 値が #FFFDF5E6 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen OldLace
        {
            get { return GetPen(CColor.OldLace); }
        }

        /// <summary>幅 1、ARGB 値が #FF808000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Olive
        {
            get { return GetPen(CColor.Olive); }
        }

        /// <summary>幅 1、ARGB 値が #FF6B8E23 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen OliveDrab
        {
            get { return GetPen(CColor.OliveDrab); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFA500 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Orange
        {
            get { return GetPen(CColor.Orange); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF4500 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen OrangeRed
        {
            get { return GetPen(CColor.OrangeRed); }
        }

        /// <summary>幅 1、ARGB 値が #FFDA70D6 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Orchid
        {
            get { return GetPen(CColor.Orchid); }
        }

        /// <summary>幅 1、ARGB 値が #FFEEE8AA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PaleGoldenrod
        {
            get { return GetPen(CColor.PaleGoldenrod); }
        }

        /// <summary>幅 1、ARGB 値が #FF98FB98 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PaleGreen
        {
            get { return GetPen(CColor.PaleGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFAFEEEE のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PaleTurquoise
        {
            get { return GetPen(CColor.PaleTurquoise); }
        }

        /// <summary>幅 1、ARGB 値が #FFDB7093 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PaleVioletRed
        {
            get { return GetPen(CColor.PaleVioletRed); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFEFD5 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PapayaWhip
        {
            get { return GetPen(CColor.PapayaWhip); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFDAB9 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PeachPuff
        {
            get { return GetPen(CColor.PeachPuff); }
        }

        /// <summary>幅 1、ARGB 値が #FFCD853F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Peru
        {
            get { return GetPen(CColor.Peru); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFC0CB のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Pink
        {
            get { return GetPen(CColor.Pink); }
        }

        /// <summary>幅 1、ARGB 値が #FFDDA0DD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Plum
        {
            get { return GetPen(CColor.Plum); }
        }

        /// <summary>幅 1、ARGB 値が #FFB0E0E6 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen PowderBlue
        {
            get { return GetPen(CColor.PowderBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF800080 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Purple
        {
            get { return GetPen(CColor.Purple); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF0000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Red
        {
            get { return GetPen(CColor.Red); }
        }

        /// <summary>幅 1、ARGB 値が #FFBC8F8F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen RosyBrown
        {
            get { return GetPen(CColor.RosyBrown); }
        }

        /// <summary>幅 1、ARGB 値が #FF4169E1 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen RoyalBlue
        {
            get { return GetPen(CColor.RoyalBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF8B4513 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SaddleBrown
        {
            get { return GetPen(CColor.SaddleBrown); }
        }

        /// <summary>幅 1、ARGB 値が #FFFA8072 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Salmon
        {
            get { return GetPen(CColor.Salmon); }
        }

        /// <summary>幅 1、ARGB 値が #FFF4A460 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SandyBrown
        {
            get { return GetPen(CColor.SandyBrown); }
        }

        /// <summary>幅 1、ARGB 値が #FF2E8B57 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SeaGreen
        {
            get { return GetPen(CColor.SeaGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFF5EE のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SeaShell
        {
            get { return GetPen(CColor.SeaShell); }
        }

        /// <summary>幅 1、ARGB 値が #FFA0522D のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Sienna
        {
            get { return GetPen(CColor.Sienna); }
        }

        /// <summary>幅 1、ARGB 値が #FFC0C0C0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Silver
        {
            get { return GetPen(CColor.Silver); }
        }

        /// <summary>幅 1、ARGB 値が #FF87CEEB のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SkyBlue
        {
            get { return GetPen(CColor.SkyBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF6A5ACD のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SlateBlue
        {
            get { return GetPen(CColor.SlateBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FF708090 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SlateGray
        {
            get { return GetPen(CColor.SlateGray); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFAFA のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Snow
        {
            get { return GetPen(CColor.Snow); }
        }

        /// <summary>幅 1、ARGB 値が #FF00FF7F のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SpringGreen
        {
            get { return GetPen(CColor.SpringGreen); }
        }

        /// <summary>幅 1、ARGB 値が #FF4682B4 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen SteelBlue
        {
            get { return GetPen(CColor.SteelBlue); }
        }

        /// <summary>幅 1、ARGB 値が #FFD2B48C のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Tan
        {
            get { return GetPen(CColor.Tan); }
        }

        /// <summary>幅 1、ARGB 値が #FF008080 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Teal
        {
            get { return GetPen(CColor.Teal); }
        }

        /// <summary>幅 1、ARGB 値が #FFD8BFD8 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Thistle
        {
            get { return GetPen(CColor.Thistle); }
        }

        /// <summary>幅 1、ARGB 値が #FFFF6347 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Tomato
        {
            get { return GetPen(CColor.Tomato); }
        }

        /// <summary>幅 1、ARGB 値が #00000000 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Transparent
        {
            get { return GetPen(CColor.Transparent); }
        }

        /// <summary>幅 1、ARGB 値が #FF40E0D0 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Turquoise
        {
            get { return GetPen(CColor.Turquoise); }
        }

        /// <summary>幅 1、ARGB 値が #FFEE82EE のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Violet
        {
            get { return GetPen(CColor.Violet); }
        }

        /// <summary>幅 1、ARGB 値が #FFF5DEB3 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Wheat
        {
            get { return GetPen(CColor.Wheat); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFFFF のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen White
        {
            get { return GetPen(CColor.White); }
        }

        /// <summary>幅 1、ARGB 値が #FFF5F5F5 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen WhiteSmoke
        {
            get { return GetPen(CColor.WhiteSmoke); }
        }

        /// <summary>幅 1、ARGB 値が #FFFFFF00 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen Yellow
        {
            get { return GetPen(CColor.Yellow); }
        }

        /// <summary>幅 1、ARGB 値が #FF9ACD32 のシステム定義 System.NetFramework.Pen オブジェクト。</summary>
        public static Pen YellowGreen
        {
            get { return GetPen(CColor.YellowGreen); }
        }
        #endregion
    }
    #endregion

    #region BaseBrushクラス
    /// <summary>SolidColorBrush、HatchBrush、ImageBrushの互換性を保つクラス</summary>
    /// <remarks>生成方法と注意
    /// <para>生成は単にSolidColorBrush、HatchBrush、ImageBrushのいずれかを代入するだけです。</para>
    /// <para>ImageBrushで作成する場合は作成コストがかなり掛かるので事前に作成しておくことをお勧めします。</para></remarks>
    public class BaseBrush : DependencyObject
    {
        private HatchBrush HB;
        private ImageBrush IB;
        private SolidColorBrush SB;
        private BrushType Type;
        private int SBColor;
        private CustomWriteableBitmap IBImage;
        private byte IBOpacity;

        private BaseBrush(HatchBrush Obj)
        {
            this.HB = Obj;
            this.Type = BrushType.HatchBrush;
        }

        private BaseBrush(ImageBrush Obj)
        {
            if (!(Obj.ImageSource is BitmapImage))
                throw new ArgumentException("ImageBrushのImageSourceがnullまたはBitmapImageでない場合はこのクラスを初期かできません。", "Obj");

            WriteableBitmap bmp = new WriteableBitmap((BitmapImage)Obj.ImageSource);

            this.IBImage = new CustomWriteableBitmap(bmp);
            this.IBOpacity = (byte)(Obj.Opacity * 0xFF);

            this.IB = Obj;
            this.Type =  BrushType.ImageBrush;
        }

        private BaseBrush(SolidColorBrush Obj)
        {
            this.SB = Obj;
            this.Type =  BrushType.SolidColorBrush;
            SBColor = this.SB.Color.ToArgb();
        }

        /// <summary>初期化した時のブラシの種類がHatchBrushであるかどうかを取得する</summary>
        public BrushType BrushType
        {
            get { return this.Type; }
            private set { this.Type = value; }
        }

        /// <summary>初期化した時のブラシから色を取得する</summary>
        /// <param name="X">初期化ブラシがHatchBrushだった場合の描画する座標値X</param>
        /// <param name="Y">初期化ブラシがHatchBrushだった場合の描画する座標値Y</param>
        /// <returns>取得したピクセルのARGB形式の色情報</returns>
        public int GetPixel(int X, int Y)
        {
            switch (this.Type)
            {
                case BrushType.HatchBrush:
                    return this.HB.GetPatternPixel(X, Y);

                case BrushType.ImageBrush:
                    return GetPixelImage(X, Y);

                case BrushType.SolidColorBrush:
                    return this.SBColor;

                default:
                    return 0;
            }
        }

        /// <summary>SolidColorBrushのピクセル情報を取得する</summary>
        /// <returns>取得したピクセルのARGB形式の色情報</returns>
        public int GetPixelSolid()
        {
            return this.SBColor;
        }

        /// <summary>SolidColorBrushのピクセル情報を取得する</summary>
        /// <param name="X">無視される</param>
        /// <param name="Y">無視される</param>
        /// <returns>取得したピクセルのARGB形式の色情報</returns>
        public int GetPixelSolid(int X, int Y)
        {
            return this.SBColor;
        }

        /// <summary>HatchBrushのピクセル情報を取得する</summary>
        /// <param name="X">描画する座標値X</param>
        /// <param name="Y">描画する座標値Y</param>
        /// <returns>取得したピクセルのARGB形式の色情報</returns>
        /// <exception cref="System.NullReferenceException">初期化時にHatchBrushで初期化していなかった場合に発生</exception>
        public int GetPixelHatch(int X, int Y)
        {
            return this.HB.GetPatternPixel(X, Y);
        }

        /// <summary>ImageBrushのピクセル情報を取得する</summary>
        /// <param name="X">描画する座標値X</param>
        /// <param name="Y">描画する座標値Y</param>
        /// <returns>取得したピクセルのARGB形式の色情報</returns>
        public int GetPixelImage(int X, int Y)
        {
            return this.IBImage[X % this.IBImage.PixelWidth, Y % this.IBImage.PixelHeight].NewBlendArgb(this.IBOpacity);
        }

        /// <summary>対応するブラシを取得する</summary>
        /// <returns>初期化時に作成したブラシ</returns>
        public object GetBrush()
        {
            object res;

            switch (this.Type)
            {
                case BrushType.HatchBrush:
                    res = this.HB;
                    break;

                case BrushType.ImageBrush:
                    res = this.IB;
                    break;

                case BrushType.SolidColorBrush:
                    res = this.SB;
                    break;

                default:
                    res = null;
                    break;
            }

            return res;
        }

        /// <summary>BaseBrushをHatchBrushに変換する</summary>
        /// <param name="Obj">対象のBaseBrush</param>
        /// <returns>変換後のHatchBrush</returns>
        public static implicit operator HatchBrush(BaseBrush Obj)
        {
            return Obj.HB;
        }

        /// <summary>HatchBrushをBaseBrushに変換する</summary>
        /// <param name="Obj">対象のHatchBrush</param>
        /// <returns>変換後のBaseBrush</returns>
        public static implicit operator BaseBrush(HatchBrush Obj)
        {
            return new BaseBrush(Obj);
        }

        /// <summary>BaseBrushをImageBrushに変換する</summary>
        /// <param name="Obj">対象のBaseBrush</param>
        /// <returns>変換後のImageBrush</returns>
        public static implicit operator ImageBrush(BaseBrush Obj)
        {
            return Obj.IB;
        }

        /// <summary>ImageBrushをBaseBrushに変換する</summary>
        /// <param name="Obj">対象のImageBrush</param>
        /// <returns>変換後のBaseBrush</returns>
        public static implicit operator BaseBrush(ImageBrush Obj)
        {
            return new BaseBrush(Obj);
        }

        /// <summary>BaseBrushをSolidColorBrushに変換する</summary>
        /// <param name="Obj">対象のBaseBrush</param>
        /// <returns>変換後のSolidColorBrush</returns>
        public static implicit operator SolidColorBrush(BaseBrush Obj)
        {
            return Obj.SB;
        }

        /// <summary>SolidColorBrushをBaseBrushに変換する</summary>
        /// <param name="Obj">対象のSolidColorBrush</param>
        /// <returns>変換後のBaseBrush</returns>
        public static implicit operator BaseBrush(SolidColorBrush Obj)
        {
            return new BaseBrush(Obj);
        }
    }
    #endregion

    #region HatchBrushクラス
    /// <summary>パターンで塗りつぶすブラシ</summary>
    public class HatchBrush
    {
        /// <summary>背景色</summary>
        private Color BColor;

        /// <summary>パターンを書く色</summary>
        private Color FColor;

        /// <summary>HatchBrushのパターン識別子</summary>
        private HatchStyle HStyle;

        /// <summary>パターンを作成して入れておく HatchPattern[Y,X]</summary>
        private int[,] HatchPattern;

        /// <summary>パターンのサイズ(縦横同じ)</summary>
        private const int size = 256;

        /// <summary>パターンの間隔 - 1(8だったら7とか2進数である一部の全てが1になる数のみ)</summary>
        private const int interval = 0x07;

        /// <summary>現在のスタイルを取得する</summary>
        public HatchStyle HatchStyle
        {
            get { return this.HStyle; }
        }

        /// <summary>現在の背景色を取得する</summary>
        public Color BackgroundColor
        {
            get { return this.BColor; }
        }

        /// <summary>現在の前景色を取得する</summary>
        public Color ForegroundColor
        {
            get { return this.FColor; }
        }

        /// <summary>単色ブラシを返す(色はForegroundColorから取得)</summary>
        /// <param name="Obj">HatchBrushオブジェクト</param>
        /// <returns>単色ブラシ</returns>
        public static explicit operator SolidColorBrush(HatchBrush Obj)
        {
            return new SolidColorBrush(Obj.ForegroundColor);
        }

        /// <summary>指定位置に描画するピクセルを取得する</summary>
        /// <param name="X">描画する座標X</param>
        /// <param name="Y">描画する座標Y</param>
        /// <returns>描画する座標に設定するべきピクセル(ARGB形式)</returns>
        public int GetPatternPixel(int X, int Y)
        {
            return this.HatchPattern[unchecked((byte)Y), unchecked((byte)X)];
        }

        /// <summary>パターンを作成する</summary>
        private void CreateHatchPattern()
        {
            this.HatchPattern = new int[size, size];
            int FC = this.FColor.ToArgb();
            int FCSub = FC.NewArgb(128);
            int BC = this.BColor.ToArgb();

            switch (this.HStyle)
            {
                case HatchStyle.Horizontal:
                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((i & interval) == 0)
                                this.HatchPattern[i, j] = FC;
                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }
                    break;

                case HatchStyle.Vertical:
                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((j & interval) == 0)
                                this.HatchPattern[i, j] = FC;
                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }
                    break;

                case HatchStyle.ForwardDiagonal:
                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((i & interval) == (j & interval))
                            {
                                this.HatchPattern[i, j] = FC;

                                if (j - 1 >= 0) this.HatchPattern[i, j - 1] = FCSub;
                                if (i - 1 >= 0) this.HatchPattern[i - 1, j] = FCSub;
                            }
                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }
                    break;

                case HatchStyle.BackwardDiagonal:
                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((i & interval) == (interval ^ (j & interval)))
                            {
                                this.HatchPattern[i, j] = FC;

                                if (j + 1 < size) this.HatchPattern[i, j + 1] = FCSub;
                                if (i - 1 >= 0) this.HatchPattern[i - 1, j] = FCSub;
                                j++;
                            }
                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }
                    break;

                case HatchStyle.Cross:
                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((i & interval) == 0 || (j & interval) == 0)
                                this.HatchPattern[i, j] = FC;
                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }
                    break;

                case HatchStyle.DiagonalCross:
                    int FCCross = FC.NewArgb(192);

                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if ((i & interval) == (j & interval))
                            {
                                this.HatchPattern[i, j] = FC;

                                if (j - 1 >= 0) this.HatchPattern[i, j - 1] = FCSub;
                                if (i - 1 >= 0) this.HatchPattern[i - 1, j] = FCSub;
                            }

                            else if ((i & interval) == (interval ^ (j & interval)))
                            {
                                this.HatchPattern[i, j] = FC;

                                if (j + 1 < size) this.HatchPattern[i, j + 1] = FCSub;
                                if (i - 1 >= 0) this.HatchPattern[i - 1, j] = FCSub;
                                j++;
                            }

                            else
                                this.HatchPattern[i, j] = BC;
                        }
                    }

                    for (int i = 0; i < size; i++)
                    {
                        for (int j = 0; j < size; j++)
                        {
                            if (((i & interval) == (j & interval)) &&  ((i & interval) == (interval ^ (j & interval))))
                            {
                                if (j - 1 >= 0) this.HatchPattern[i, j - 1] = FCCross;
                                if (i - 1 >= 0) this.HatchPattern[i - 1, j] = FCCross;
                                if (j + 1 < size) this.HatchPattern[i, j + 1] = FCCross;
                                if (i + 1 < size) this.HatchPattern[i + 1, j] = FCCross;
                            }
                        }
                    }
                    break;
            }
        }

        /// <summary>コンストラクタ</summary>
        public HatchBrush()
            : base()
        {
            CreateHatchPattern();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Style">適用するスタイル</param>
        /// <param name="ForegroundColor">前景色</param>
        public HatchBrush(HatchStyle Style, Color ForegroundColor)
            : base()
        {
            this.HStyle = Style;
            this.FColor = ForegroundColor;
            this.BColor = Color.FromArgb(0, 0, 0, 0);
            CreateHatchPattern();
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Style">適用するスタイル</param>
        /// <param name="ForegroundColor">前景色</param>
        /// <param name="BackgroundColor">背景色</param>
        public HatchBrush(HatchStyle Style, Color ForegroundColor, Color BackgroundColor)
            : base()
        {
            this.HStyle = Style;
            this.FColor = ForegroundColor;
            this.BColor = BackgroundColor;
            CreateHatchPattern();
        }
    }
    #endregion

    #region Fontクラス
    /// <summary>.NET FrameworkのFontとほぼ同等なFont</summary>
    //[System.ComponentModel.TypeConverterAttribute(typeof(FontConverter))]
    public class Font
    {
        #region フィールド・プロパティ
        private FontFamily FFamily;
        private double FSize;
        private FontStyle FStyle;
        private FontWeight FWeight;

        /// <summary>フォントの種類を取得・設定する</summary>
        public FontFamily Family
        {
            get { return this.FFamily; }
            set { this.FFamily = value; }
        }

        /// <summary>フォントのサイズを取得・設定する</summary>
        [DefaultValue(8.25)]
        public double Size
        {
            get { return this.FSize; }
            set { this.FSize = value; }
        }

        /// <summary>フォントのスタイルを取得・設定する</summary>
        public FontStyle Style
        {
            get { return this.FStyle; }
            set { this.FStyle = value; }
        }

        /// <summary>フォントの太さを取得・設定する</summary>
        public FontWeight Weight
        {
            get { return this.FWeight; }
            set { this.FWeight = value; }
        }
        #endregion

        #region コンストラクタ・メソッド
        /// <summary>コンストラクタ</summary>
        /// <param name="FontName">使用するフォントを選択する</param>
        public Font(FontFamilyConstants FontName)
        {
            this.FFamily = new FontFamily(FontName.ToString().Replace('_', ' '));
            this.FSize = 8.25;
            this.FStyle = FontStyles.Normal;
            this.FWeight = FontWeights.Normal;
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="FontName">使用するフォント</param>
        /// <param name="FontSize">フォントのサイズ</param>
        public Font(FontFamilyConstants FontName, double FontSize)
        {
            this.FFamily = new FontFamily(FontName.ToString().Replace('_',' '));
            this.FSize = FontSize;
            this.FStyle = FontStyles.Normal;
            this.FWeight = FontWeights.Normal;
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="FontName">使用するフォント</param>
        public Font(String FontName)
        {
            this.FFamily = new FontFamily(FontName);
            this.FSize = 8.25;
            this.FStyle = FontStyles.Normal;
            this.FWeight = FontWeights.Normal;
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="FontName">使用するフォント</param>
        /// <param name="FontSize">フォントのサイズ</param>
        public Font(String FontName, double FontSize)
        {
            this.FFamily = new FontFamily(FontName);
            this.FSize = FontSize;
            this.FStyle = FontStyles.Normal;
            this.FWeight = FontWeights.Normal;
        }

        /// <summary>現在のインスタンスを表す文字列を返す</summary>
        /// <returns>現在のインスタンスを表す文字列</returns>
        public override string ToString()
        {
            return string.Format("{0},{1},{2},{3}", this.Family, this.Size, this.Style, this.Weight);
        }
        #endregion
    }
    #endregion

    //public class FontConverter : System.ComponentModel.TypeConverter
    //{
    //    //コンバータがオブジェクトを指定した型に変換できるか
    //    //（変換できる時はTrueを返す）
    //    //ここでは、CustomClass型のオブジェクトには変換可能とする
    //    public override bool CanConvertTo(
    //        ITypeDescriptorContext context, Type destinationType)
    //    {
    //        if (destinationType == typeof(Font)) return true;

    //        return base.CanConvertTo(context, destinationType);
    //    }

    //    //指定した値オブジェクトを、指定した型に変換する
    //    //CustomClass型のオブジェクトをString型に変換する方法を提供する
    //    public override object ConvertTo(ITypeDescriptorContext context,
    //        CultureInfo culture, object value, Type destinationType)
    //    {
    //        if (destinationType == typeof(string) &&
    //            value is Font)
    //        {
    //            Font font = (Font)value;

    //            return font.ToString();
    //        }
    //        return base.ConvertTo(context, culture, value, destinationType);
    //    }

    //    //コンバータが特定の型のオブジェクトをコンバータの型に変換できるか
    //    //（変換できる時はTrueを返す）
    //    //ここでは、String型のオブジェクトなら変換可能とする
    //    public override bool CanConvertFrom(
    //        ITypeDescriptorContext context, Type sourceType)
    //    {
    //        if (sourceType == typeof(string))
    //            return true;
    //        return base.CanConvertFrom(context, sourceType);
    //    }

    //    //指定した値をコンバータの型に変換する
    //    //String型のオブジェクトをCustomClass型に変換する方法を提供する
    //    public override object ConvertFrom(ITypeDescriptorContext context,
    //        CultureInfo culture, object value)
    //    {
    //        if (value is string)
    //        {
    //            //System.Text.RegularExpressions.Regex rg = new System.Text.RegularExpressions.Regex(

    //            string[] str = value.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
    //            Font f = new Font(str[0],Convert.ToDouble(str[1]));
    //            f.Style = FontStyles.Normal;// str[2];
    //            f.Weight = FontWeights.Normal;

    //            return f;
    //        }
    //        return base.ConvertFrom(context, culture, value);
    //    }
    //}

    #region GraphicsBoxクラス
    /// <summary>Gridの上にImageとCanvasを乗せたコントロール</summary>
    [Description("Gridの上にImageとCanvasを乗せたコントロールを提供する。")]
    public class GraphicsBox : Grid
    {
        /// <summary>上に乗せるキャンバスボード</summary>
        protected Canvas BaseCanvas;

        /// <summary>上に乗せるイメージ</summary>
        protected Image ImageBox;

        #region 依存関係プロパティ関連
        /// <summary>GraphicsBox.Image依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty ImageProperty;

        /// <summary>GraphicsBox.Canvas依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty CanvasProperty;

        /// <summary>GraphicsBox.SizeMode依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty SizeModeProperty;

        /// <summary>GraphicsBox.BaseChildren依存関係プロパティを識別します。</summary>
        protected static readonly DependencyProperty BaseChildrenProperty;

        /// <summary>GraphicsBox.Width依存関係プロパティを識別します。</summary>
        public new static readonly DependencyProperty WidthProperty;

        /// <summary>GraphicsBox.Height依存関係プロパティを識別します。</summary>
        public new static readonly DependencyProperty HeightProperty;

        /// <summary>依存関係プロパティの初期化</summary>
        static GraphicsBox()
        {
            GraphicsBox.ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(GraphicsBox), new PropertyMetadata(null));
            GraphicsBox.CanvasProperty = DependencyProperty.Register("Canvas", typeof(Canvas), typeof(GraphicsBox), new PropertyMetadata(null));
            GraphicsBox.SizeModeProperty = DependencyProperty.Register("SizeMode", typeof(Stretch), typeof(GraphicsBox), new PropertyMetadata(Stretch.None));
            GraphicsBox.BaseChildrenProperty = DependencyProperty.Register("BaseChildren", typeof(UIElementCollection), typeof(GraphicsBox), new PropertyMetadata(null));
            GraphicsBox.WidthProperty = DependencyProperty.Register("Width", typeof(double), typeof(GraphicsBox), new PropertyMetadata(double.NaN));
            GraphicsBox.HeightProperty = DependencyProperty.Register("Height", typeof(double), typeof(GraphicsBox), new PropertyMetadata(double.NaN));
        }
        #endregion

        #region プロパティ
        /// <summary>表示するイメージを取得または設定します。</summary>
        [Category("表示"), DefaultValue(null), Description("表示するイメージを取得または設定します。")]
        public ImageSource Image
        {
            get { return this.ImageBox.Source; }
            set { this.ImageBox.Source = value; }
        }

        /// <summary>キャンバスを取得します。</summary>
        [ReadOnly(true)]
        public Canvas Canvas
        {
            get { return this.BaseCanvas; }
        }

        /// <summary>System.Windows.Controls.Image を表示先の四角形全体に引き伸ばす方法を表す値を取得または設定します。</summary>
        [Category("動作"), DefaultValue(Stretch.None), Description("イメージを表示する方法を取得または設定します。")]
        public Stretch SizeMode
        {
            get { return this.ImageBox.Stretch; }
            set { this.ImageBox.Stretch = value; }
        }

        /// <summary>Canvasのパネルの子要素のコレクションを取得します。</summary>
        [ReadOnly(true)]
        protected UIElementCollection BaseChildren
        {
            get { return this.BaseCanvas.Children; }
        }

        /// <summary>System.Windows.FrameworkElement の幅を取得または設定します。</summary>
        [Category("レイアウト"), DefaultValue(double.NaN), Description("この要素の幅を取得または設定します。")]
        public new double Width
        {
            get
            {
                if (double.IsNaN(base.Width))
                {
                    double res = base.Margin.Left + base.Margin.Right;
                    FrameworkElement Parent = (FrameworkElement)base.Parent;

                    if (Parent == null)
                        return double.NaN;

                    while (double.IsNaN(Parent.Width))
                    {
                        res += Parent.Margin.Left + Parent.Margin.Right;
                        Parent = (FrameworkElement)Parent.Parent;
                    }

                    res = Parent.Width - res;

                    return res;
                }

                else
                    return base.Width;
            }

            set { base.Width = value; }
        }

        /// <summary>System.Windows.FrameworkElement の高さを取得または設定します。</summary>
        [Category("レイアウト"), DefaultValue(double.NaN), Description("この要素の高さを取得または設定します。")]
        public new double Height
        {
            get
            {
                if (double.IsNaN(base.Height))
                {                    
                    double res = base.Margin.Top + base.Margin.Bottom;
                    FrameworkElement Parent = (FrameworkElement)base.Parent;

                    if (Parent == null)
                        return double.NaN;

                    while (double.IsNaN(Parent.Height))
                    {
                        res += Parent.Margin.Top + Parent.Margin.Bottom;
                        Parent = (FrameworkElement)Parent.Parent;
                    }

                    res = Parent.Height - res;

                    return res;
                }

                else
                    return base.Height;
            }
            set { base.Height = value; }
        }
        #endregion

        #region コンストラクタとメソッド
        /// <summary>コンストラクタ</summary>
        public GraphicsBox()
            : base()
        {
            this.ImageBox = new Image();
            this.BaseCanvas = new Canvas();
            base.Children.Add(this.ImageBox);
            base.Children.Add(this.BaseCanvas);
        }

        /// <summary>呼び出し元のスレッドがこのオブジェクトにアクセスできるかどうかを確認します。</summary>
        /// <returns>呼び出し元のスレッドがこのオブジェクトにアクセスできる場合は true。それ以外の場合は false。</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new bool CheckAccess()
        {
            return base.CheckAccess() && this.ImageBox.CheckAccess();
        }

        /// <summary>依存関係プロパティのローカル値をCanvasとImage共にクリアします。</summary>
        /// <param name="dp">値を消去する対象のプロパティの System.Windows.DependencyProperty 識別子。</param>
        protected new void ClearValue(DependencyProperty dp)
        {
            base.ClearValue(dp);
            this.ImageBox.ClearValue(dp);
        }

        /// <summary>依存関係プロパティのローカル値をクリアします。</summary>
        /// <param name="IsCanvas">キャンバス側のプロパティ設定かどうか</param>
        /// <param name="dp">値を消去する対象のプロパティの System.Windows.DependencyProperty 識別子。</param>
        public void ClearValue(bool IsCanvas, DependencyProperty dp)
        {
            if (IsCanvas)
                base.ClearValue(dp);

            else
                this.ImageBox.ClearValue(dp);
        }

        /// <summary>System.Windows.DependencyObject で依存関係プロパティのローカル値をCanvasとImageに設定します。</summary>
        /// <param name="dp">設定する依存関係プロパティの識別子。</param>
        /// <param name="value">新しいローカル値。</param>
        protected new void SetValue(DependencyProperty dp, object value)
        {
            base.SetValue(dp, value);
            this.ImageBox.SetValue(dp, value);
        }

        /// <summary>System.Windows.DependencyObject で依存関係プロパティのローカル値を設定します。</summary>
        /// <param name="IsCanvas">キャンバス側のプロパティ設定かどうか</param>
        /// <param name="dp">設定する依存関係プロパティの識別子。</param>
        /// <param name="value">新しいローカル値。</param>
        public void SetValue(bool IsCanvas, DependencyProperty dp, object value)
        {
            if (IsCanvas)
                base.SetValue(dp, value);

            else
                this.ImageBox.SetValue(dp, value);
        }

        /// <summary>Canvas上のオブジェクトを全て削除し、Imageに表示されているイメージを透明で塗りつぶす</summary>
        public void Clear()
        {
            this.BaseCanvas.Children.Clear();

            WriteableBitmap tmp = this.Image as WriteableBitmap;

            if (tmp != null)
                Array.Clear(tmp.Pixels, 0, tmp.Pixels.Length);
        }

        /// <summary>Canvas上のオブジェクトを全て削除し、ImageのSourceを削除する</summary>
        public void Delete()
        {
            this.BaseCanvas.Children.Clear();

            this.Image = null;
        }

        /// <summary>対象のGraphicsBoxからキャンバスを抜き出して返す</summary>
        /// <param name="Obj">対象のGraphicsBox</param>
        /// <returns>抜き出したイメージ</returns>
        protected Canvas GetBaseCanvas(GraphicsBox Obj)
        {
            return Obj.BaseCanvas;
        }

        /// <summary>対象のGraphicsBoxからイメージを抜き出して返す</summary>
        /// <param name="Obj">対象のGraphicsBox</param>
        /// <returns>抜き出したイメージ</returns>
        protected Image GetImageBox(GraphicsBox Obj)
        {
            return Obj.ImageBox;
        }

        /// <summary>GraphicsBoxをCanvasに変換する</summary>
        /// <param name="Obj">対象のGraphicsBox</param>
        /// <returns>変換後のCanvas</returns>
        public static implicit operator Canvas(GraphicsBox Obj)
        {
            return Obj.BaseCanvas;
        }

        /// <summary>GraphicsBoxをImageに変換する</summary>
        /// <param name="Obj">対象のGraphicsBox</param>
        /// <returns>変換後のImage</returns>
        public static implicit operator Image(GraphicsBox Obj)
        {
            return Obj.ImageBox;
        }
        #endregion
    }
    #endregion

    #region PictureBoxクラス
    /// <summary>.NET FrameworkのPictureBoxとほぼ同等なPictureBox</summary>
    [Description(".NET FrameworkのPictureBoxとほぼ同等なPictureBoxを提供します。")]
    public class PictureBox : GraphicsBox
    {
        /// <summary>中央のGraphicsBox(基底クラスが下のGraphicsBox)</summary>
        protected GraphicsBox BaseGraphics;

        /// <summary>上のGraphicsBox</summary>
        protected GraphicsBox RefreshGraphics;

        #region 依存関係プロパティ関連
        /// <summary>PictureBox.Image依存関係プロパティを識別します。</summary>
        public new static readonly DependencyProperty ImageProperty;

        /// <summary>PictureBox.Canvas依存関係プロパティを識別します。</summary>
        public new static readonly DependencyProperty CanvasProperty;

        /// <summary>PictureBox.SizeMode依存関係プロパティを識別します。</summary>
        public new static readonly DependencyProperty SizeModeProperty;

        /// <summary>PictureBox.BackColor依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty BackColorProperty;

        /// <summary>PictureBox.Image依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty BackgroundImageProperty;

        /// <summary>PictureBox.Canvas依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty BackgroundCanvasProperty;

        /// <summary>PictureBox.SizeMode依存関係プロパティを識別します。</summary>
        public static readonly DependencyProperty BackgroundImageLayoutProperty;

        /// <summary>依存関係プロパティの初期化</summary>
        static PictureBox()
        {
            PictureBox.ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(PictureBox), new PropertyMetadata(null));
            PictureBox.CanvasProperty = DependencyProperty.Register("Canvas", typeof(Canvas), typeof(PictureBox), new PropertyMetadata(null));
            PictureBox.SizeModeProperty = DependencyProperty.Register("SizeMode", typeof(Stretch), typeof(PictureBox), new PropertyMetadata(Stretch.None));
            PictureBox.BackColorProperty = DependencyProperty.Register("BackColor", typeof(Color), typeof(PictureBox), new PropertyMetadata(Color.FromArgb(0, 0, 0, 0)));
            PictureBox.BackgroundImageProperty = DependencyProperty.Register("BackgroundImage", typeof(ImageSource), typeof(PictureBox), new PropertyMetadata(null));
            PictureBox.BackgroundCanvasProperty = DependencyProperty.Register("BackgroundCanvas", typeof(Canvas), typeof(PictureBox), new PropertyMetadata(null));
            PictureBox.BackgroundImageLayoutProperty = DependencyProperty.Register("BackgroundImageLayout", typeof(Stretch), typeof(PictureBox), new PropertyMetadata(Stretch.None));
        }
        #endregion

        #region プロパティ

        #region 既定プロパティのオーバーライド
        /// <summary>PictureBoxに表示するイメージを取得・設定する</summary>
        [Category("表示"), DefaultValue(null), Description("表示するイメージを取得または設定します。")]
        public new ImageSource Image
        {
            get { return this.BaseGraphics.Image; }
            set { this.BaseGraphics.Image = value; }
        }

        /// <summary>PictureBoxのキャンバスを取得する</summary>
        public new Canvas Canvas
        {
            get { return this.BaseGraphics.Canvas; }
        }

        /// <summary>イメージをどう配置するか取得・設定する</summary>
        [Category("動作"), DefaultValue(Stretch.None), Description("イメージを表示する方法を取得または設定します。")]
        public new Stretch SizeMode
        {
            get { return this.BaseGraphics.SizeMode; }
            set { this.BaseGraphics.SizeMode = value; }
        }
        #endregion

        #region 新規プロパティ
        /// <summary>背景色を取得・設定する</summary>
        [Category("表示"), Description("この要素の背景色を取得または設定します。")]
        public Color BackColor
        {
            get { return (base.Background is SolidColorBrush ? (base.Background as SolidColorBrush).Color : Color.FromArgb(0, 0, 0, 0)); }
            set { base.Background = new SolidColorBrush(value); }
        }

        /// <summary>背景のイメージを取得・設定する</summary>
        [Category("表示"), DefaultValue(null), Description("この要素の背景イメージを取得または設定します。")]
        public ImageSource BackgroundImage
        {
            get { return base.Image; }
            set { base.Image = value; }
        }

        /// <summary>背景のキャンバスを取得する</summary>
        [ReadOnly(true)]
        public Canvas BackgroundCanvas
        {
            get { return base.Canvas; }
        }

        /// <summary>背景のイメージをどう配置するか取得・設定する</summary>
        [Category("動作"), DefaultValue(Stretch.None), Description("背景イメージの設定方法を取得または設定します。")]
        public Stretch BackgroundImageLayout
        {
            get { return base.SizeMode; }
            set { base.SizeMode = value; }
        }
        #endregion

        #endregion

        #region 無効化メンバとコンストラクタ
        /// <summary>無効です</summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new CacheMode CacheMode { set { } }

        /// <summary>無効です</summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new void Clear() { }

        /// <summary>無効です</summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new void InvalidateArrange() { }

        /// <summary>無効です</summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new void InvalidateMeasure() { }
        
        /// <summary>コンストラクタ</summary> 
        public PictureBox()
            : base()
        {
            this.BaseGraphics = new GraphicsBox();
            this.RefreshGraphics = new GraphicsBox();
            this.RefreshGraphics.SizeMode = Stretch.Fill;
            base.Children.Add(this.BaseGraphics);
            base.Children.Add(this.RefreshGraphics);
            base.Background = new SolidColorBrush(Color.FromArgb(0, 0, 0, 0));
            this.RefreshGraphics.LayoutUpdated += new EventHandler(RefreshGraphics_LayoutUpdated);
        }

        /// <summary>RefreshGraphicsのための再描画メソッド</summary>
        /// <param name="sender">RefreshGraphics自身</param>
        /// <param name="e">イベントの情報</param>
        private void RefreshGraphics_LayoutUpdated(object sender,EventArgs e)
        {
            WriteableBitmap bmp = this.RefreshGraphics.Image as WriteableBitmap;

            if (bmp != null)
                bmp.Invalidate();
        }
        #endregion

        #region メソッド

        #region 既定メソッドのオーバーライド
        /// <summary>呼び出し元のスレッドがこのオブジェクトにアクセスできるかどうかを確認します。</summary>
        /// <returns>呼び出し元のスレッドがこのオブジェクトにアクセスできる場合は true。それ以外の場合は false。</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new bool CheckAccess()
        {
            return base.CheckAccess() && this.BaseGraphics.CheckAccess() && this.RefreshGraphics.CheckAccess();
        }

        /// <summary>全ての階層の依存関係プロパティのローカル値をクリアします。</summary>
        /// <param name="dp">値を消去する対象のプロパティの System.Windows.DependencyProperty 識別子。</param>
        protected new void ClearValue(DependencyProperty dp) 
        {
            base.ClearValue(dp);
            this.BaseGraphics.ClearValue(dp);
            this.RefreshGraphics.ClearValue(dp);
        }

        /// <summary>依存関係プロパティのローカル値をクリアします。</summary>
        /// <param name="Hierarchy">階層の深さを示す</param>
        /// <param name="dp">値を消去する対象のプロパティの System.Windows.DependencyProperty 識別子。</param>
        protected void ClearValue(Hierarchy Hierarchy, DependencyProperty dp)
        {
            switch (Hierarchy)
            {
                case Hierarchy.BackgroundCanvas:
                    base.ClearValue(true, dp);
                    break;

                case Hierarchy.BackgroundImage:
                    base.ClearValue(false, dp);
                    break;

                case Hierarchy.BaseCanvas:
                    this.BaseGraphics.ClearValue(true, dp);
                    break;

                case Hierarchy.BaseImage:
                    this.BaseGraphics.ClearValue(false, dp);
                    break;

                case Hierarchy.RefreshCanvas:
                    this.RefreshGraphics.ClearValue(true, dp);
                    break;

                case Hierarchy.RefreshImage:
                    this.RefreshGraphics.ClearValue(false, dp);
                    break;
            }
        }

        /// <summary>System.Windows.DependencyObject で依存関係プロパティのローカル値を全ての階層で設定します。</summary>
        /// <param name="dp">設定する依存関係プロパティの識別子。</param>
        /// <param name="value">新しいローカル値。</param>
        protected new void SetValue(DependencyProperty dp, object value)
        {
            base.SetValue(dp, value);
            this.BaseGraphics.SetValue(dp, value);
            this.RefreshGraphics.SetValue(dp, value);
        }

        /// <summary>System.Windows.DependencyObject で依存関係プロパティのローカル値を設定します。</summary>
        /// <param name="Hierarchy">階層の深さを示す</param>
        /// <param name="dp">設定する依存関係プロパティの識別子。</param>
        /// <param name="value">新しいローカル値。</param>
        protected void SetValue(Hierarchy Hierarchy, DependencyProperty dp, object value)
        {
            switch (Hierarchy)
            {
                case Hierarchy.BackgroundCanvas:
                    base.SetValue(true, dp,value);
                    break;

                case Hierarchy.BackgroundImage:
                    base.SetValue(false, dp,value);
                    break;

                case Hierarchy.BaseCanvas:
                    this.BaseGraphics.SetValue(true, dp,value);
                    break;

                case Hierarchy.BaseImage:
                    this.BaseGraphics.SetValue(false, dp,value);
                    break;

                case Hierarchy.RefreshCanvas:
                    this.RefreshGraphics.SetValue(true, dp,value);
                    break;

                case Hierarchy.RefreshImage:
                    this.RefreshGraphics.SetValue(false, dp,value);
                    break;
            }
        }
        #endregion

        #region 新規メソッド
        /// <summary>コントロールを強制的に再描画する</summary>
        public void Refresh()
        {
            this.RefreshGraphics.Clear();
            base.UpdateLayout();
        }

        /// <summary>コントロールを再描画します</summary>
        public void Invalidate()
        {
            this.RefreshGraphics.Clear();
            base.InvalidateArrange();
        }

        /// <summary>RVGraphicsを作成して返す</summary>
        public RVGraphics CreateGraphics()
        {
            this.RefreshGraphics.Image = new WriteableBitmap((int)Math.Ceiling(this.Width), (int)Math.Ceiling(this.Height));;
            return Graphics.FromGraphicsBox(this.RefreshGraphics);
        }
        #endregion

        #endregion
    }
    #endregion

    #region Graphics系クラス

    #region Graphicsクラス
    /// <summary>Graphics系クラスの基底クラス</summary>
    /// <remarks><para>RasterGraphics、VectorGraphics、RVGraphicsの基底クラス</para>
    /// <para>この3つのクラスならどれでも入れれるので引数渡しの時などに使用します。</para>
    /// <para>このクラス自体は抽象クラスなのでインスタンスは作れません。</para>
    /// <example><para>Graphics g = Graphics.FromImage(wbmp); //WriteableBitmap・CustomWriteableBitmapを対象とするRasterGraphicsを作成</para>
    /// <para>Graphics g = Graphics.FromCanvas(cvs); //Canvasを対象とするVectorGraphicsを作成</para>
    /// <para>Graphics g = Graphics.FromGraphicsBox(gb); //FromGraphicsBoxを対象とするRVGraphicsを作成</para></example></remarks>
    public abstract class Graphics
    {
        /// <summary>WriteableBitmapを対象とするRasterGraphicsオブジェクトを作って返す</summary>
        /// <param name="Target">対象のWriteableBitmap</param>
        /// <returns>作成されたRasterGraphicsオブジェクト</returns>
        public static RasterGraphics FromImage(WriteableBitmap Target)
        {
            RasterGraphics g = new RasterGraphics(Target);
            return g;
        }

        /// <summary>CustomWriteableBitmapを対象とするRasterGraphicsオブジェクトを作って返す</summary>
        /// <param name="Target">対象のCustomWriteableBitmap</param>
        /// <returns>作成されたRasterGraphicsオブジェクト</returns>
        public static RasterGraphics FromImage(CustomWriteableBitmap Target)
        {
            RasterGraphics g = new RasterGraphics(Target);
            return g;
        }

        /// <summary>Canvasを対象とするVectorGraphicsオブジェクトを作って返す</summary>
        /// <param name="Target">対象のCanvas</param>
        /// <returns>作成されたVectorGraphicsオブジェクト</returns>
        public static VectorGraphics FromCanvas(Canvas Target)
        {
            VectorGraphics g = new VectorGraphics(Target);
            return g;
        }

        /// <summary>GraphicsBoxを対象とするRVGraphicsオブジェクトを作って返す</summary>
        /// <param name="Target">対象のGraphicsBox</param>
        /// <returns>作成されたRVGraphicsオブジェクト</returns>
        /// <exception cref="System.ArgumentException">Targetにイメージが入っていないか形式がCustomWriteableBitmap、WriteableBitmapではない場合に発生</exception>
        public static RVGraphics FromGraphicsBox(GraphicsBox Target)
        {
            RVGraphics g = new RVGraphics(Target);
            return g;
        }
    }
    #endregion

    #region RVGraphicsクラス
    /// <summary>RasterGraphicsとVectorGraphicsを合わせて扱うクラス</summary>
    /// <remarks>注意
    /// <para>このクラスはRasterGraphicsを作成します。</para>
    /// <para>RasterGraphicsはCustomWriteableBitmapクラスを使うので作成コストが掛かります。(直接CustomWriteableBitmapを入れたときを除く)</para>
    /// <para>従ってこのクラスを使うときは事前に作成しておく事をお勧めします。</para>
    /// <example><para>RVGraphics g = new RVGraphics(gb); //gbはGraphicsBox(ImageにCustomWriteableBitmapまたはWriteableBitmapを入れた状態)</para>
    /// <para>RVGraphics g = Graphics.FromGraphicsBox(gb);</para>
    /// <para>g.Raster //RasterGraphicsにアクセス</para>
    /// <para>g.Vector //VectorGraphicsにアクセス</para>
    /// <para>g.Raster.Clear(); //実際にはどちらかにアクセスしてメソッドを呼び出したりする。</para></example></remarks>
    public class RVGraphics : Graphics
    {
        private RasterGraphics RG;
        private VectorGraphics VG;      

        /// <summary>RasterGraphicsを返す</summary>
        /// <returns>内部のRasterGraphics</returns>
        public System.NetFramework.RasterGraphics Raster { get { return this.RG; } }

        /// <summary>VectorGraphicsを返す</summary>
        /// <returns>内部のVectorGraphics</returns>
        public System.NetFramework.VectorGraphics Vector { get { return this.VG; } }

        /// <summary>RasterGraphicsとVectorGraphicsのどちらか指定した方を返す</summary>
        /// <param name="IsRasterGraphics">RasterGraphicsを指定するかどうか</param>
        /// <returns>指定されたGraphicsオブジェクト</returns>
        public Graphics Access(bool IsRasterGraphics)
        {
            return (IsRasterGraphics ? (Graphics)this.RG : (Graphics)this.VG);
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">処理の対象</param>
        /// <exception cref="System.ArgumentException">Targetにイメージが入っていないか形式がWriteableBitmapではない場合に発生</exception>
        public RVGraphics(GraphicsBox Target)
        {
            WriteableBitmap bmp = Target.Image as WriteableBitmap;

            if (bmp == null)
                throw new ArgumentException("GraphicsBoxのイメージが入っていないか、WriteableBitmapではありません。", "Target");

            this.VG = new VectorGraphics(Target.Canvas);
            this.RG = new RasterGraphics(bmp);
        }
    }
    #endregion

    #region RasterGraphicsクラス
    /// <summary>.NET FrameworkのGraphicsとほぼ同等なクラス</summary>
    /// <remarks>注意
    /// <para>このクラスはアクセス速度向上のために作成コストを犠牲にするCustomWriteableBitmapクラスを使用しています。</para>
    /// <para>従って描画をする時にこのクラスを作成すると速度の向上が望めません。</para>
    /// <para>このクラスを使うときは事前に作成しておく事をお勧めします。</para>
    /// <para>またはCustomWriteableBitmapで初期化する事をお勧めします。</para>
    /// <example><para>RasterGraphics g = new RasterGraphics(wbmp); //wbmpはCustomWriteableBitmapまたはWriteableBitmap</para>
    /// <para>RasterGraphics g = Graphics.FromImage(wbmp);</para>
    /// <para>g.Clear(); //メソッド使用</para></example></remarks>
    public class RasterGraphics : Graphics
    {
        #region フィールド・プロパティ・その他のメソッド
        /// <summary>処理対象のイメージ</summary>
        private CustomWriteableBitmap Target;

        /// <summary>イメージと図形の上塗りの方式を決める</summary>
        public CompositingMode CompositingMode { get; set; }

        /// <summary>描画時の品質を決める</summary>
        public SmoothingMode SmoothingMode { get; set; }

        /// <summary>イメージ描画に使うラスターオペレーション用のパターンカラー</summary>
        public Color PatternColor
        {
            get { return this.Target.PatternColor; }
            set { this.Target.PatternColor = value; }
        }

        /// <summary>指定した座標のピクセルを取得または設定する</summary>
        /// <param name="Index">指定メモリ位置(1次元配列の位置)</param>
        /// <returns>指定されたピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の時に発生</exception>
        public int this[int Index]
        {
            get { return this.Target[Index]; }
            set { this.Target[Index] = value; }
        }

        /// <summary>指定した座標のピクセルを取得または設定する</summary>
        /// <param name="X">指定座標X</param>
        /// <param name="Y">指定座標Y</param>
        /// <returns>指定されたピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public int this[int X, int Y]
        {
            get { return this.Target[X, Y]; }
            set { this.Target[X, Y] = value; }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">対象のWriteableBitmap</param>
        public RasterGraphics(WriteableBitmap Target)
        {
            this.Target = new CustomWriteableBitmap(Target);
            this.CompositingMode = CompositingMode.SourceOver;
            this.SmoothingMode = SmoothingMode.Default;
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">対象のCustomWriteableBitmap</param>
        public RasterGraphics(CustomWriteableBitmap Target)
        {
            this.Target = Target;
            this.CompositingMode = CompositingMode.SourceOver;
            this.SmoothingMode = SmoothingMode.Default;
        }

        /// <summary>指定した色でイメージを塗りつぶす</summary>
        /// <param name="Color">塗りつぶしの色</param>
        public void Clear(Color Color)
        {
            int ARGB = Color.ToArgb();

            if (ARGB == 0)
            {
                Array.Clear(this.Target.Pixels, 0, this.Target.Pixels.Length);
                return;
            }

            for (int i = 0; i < this.Target.Pixels.Length; i++)
                this.Target.Pixels[i] = ARGB;
        }
        #endregion

        #region 直線・曲線
        /// <summary>直線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        public void DrawLine(Pen DrawPen, Point Start,Point End)
        {
            DrawLine(DrawPen, Start.X, Start.Y, End.X, End.Y);
        }

        /// <summary>直線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        public void DrawLine(Pen DrawPen, double X1, double Y1, double X2, double Y2)
        {
            if (((X1 < 0) && (X2 < 0)) || ((X1 >= this.Target.PixelWidth) && (X2 >= this.Target.PixelWidth)))
                return;

            if (((Y1 < 0) && (Y2 < 0)) || ((Y1 >= this.Target.PixelHeight) && (Y2 >= this.Target.PixelHeight)))
                return;

            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPenAA(DrawPen, X1, Y1, X2, Y2);

                else
                    this.Target.CopyPenAA(DrawPen, X1, Y1, X2, Y2);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPen(DrawPen, (int)X1, (int)Y1, (int)X2, (int)Y2);

                else
                    this.Target.CopyPen(DrawPen, (int)X1, (int)Y1, (int)X2, (int)Y2);
            }
            #endregion
        }

        /// <summary>連続した一連の直線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">一連の直線を形作る座標配列</param>
        /// <exception cref="System.ArgumentOutOfRangeException">座標の指定数が2未満だった場合に発生</exception>
        /// <remarks>このメソッドはDrawLineを複数回実行するよりもコストは掛かりますが、接続は綺麗になります。</remarks>
        public void DrawLines(Pen DrawPen, Point[] Points)
        {
            if (Points.Length < 2) throw new ArgumentOutOfRangeException("Points", "座標が二つ以上指定されていません。");

            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPensAA(DrawPen, Points, false);

                else
                    this.Target.CopyPensAA(DrawPen, Points, false);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPens(DrawPen, Points, false);

                else
                    this.Target.CopyPens(DrawPen, Points, false);
            }
            #endregion
        }

        /// <summary>ベジエ曲線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">1つ目の制御点X</param>
        /// <param name="Y2">1つ目の制御点Y</param>
        /// <param name="X3">2つ目の制御点X</param>
        /// <param name="Y3">2つ目の制御点Y</param>
        /// <param name="X4">終点X</param>
        /// <param name="Y4">終点Y</param>
        public void DrawBezier(Pen DrawPen, double X1, double Y1, double X2, double Y2, double X3, double Y3, double X4, double Y4)
        {
            DrawBezier(DrawPen, new Point(X1, Y1), new Point(X2, Y2), new Point(X3, Y3), new Point(X4, Y4));
        }

        /// <summary>ベジエ曲線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">1つ目の制御点</param>
        /// <param name="Point3">2つ目の制御点</param>
        /// <param name="Point4">終点</param>
        public void DrawBezier(Pen DrawPen, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            Bezier X, Y;
            Bezier.GetBezier(out X, out Y, Point1, Point2, Point3, Point4);

            double length = Bezier.GetBezierLength(X, Y, 8);
            if (length == 0) return;

            double dt = 15.0/length;

            double t = 0.0;
            Collections.Generic.List<Point> Points = new System.Collections.Generic.List<Point>();

            while (t < 1.0)
            {
                Points.Add(new Point(X.GetPosition(t), Y.GetPosition(t)));

                t += dt;
            }

            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPensAA(DrawPen, Points.ToArray(), false);

                else
                    this.Target.CopyPensAA(DrawPen, Points.ToArray(), false);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPens(DrawPen, Points.ToArray(), false);

                else
                    this.Target.CopyPens(DrawPen, Points.ToArray(), false);
            }
            #endregion
        }

        /// <summary>連続した一連のベジエ曲線を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        public void DrawBeziers(Pen DrawPen, Point[] Points)
        {
            if (Points.Length % 3 != 1)
                throw new ArgumentOutOfRangeException("Points", "点の数が 1 + 3n になりません。");

            int cnt = Points.Length / 3;

            for (int i = 0; i < cnt; i++)
            {
                int j = i * 3;
                Bezier X, Y;
                Bezier.GetBezier(out X, out Y, Points[j], Points[j + 1], Points[j + 2], Points[j + 3]);

                double length = Bezier.GetBezierLength(X, Y, 8);
                if (length == 0) return;

                double dt = 15.0 / length;

                double t = 0.0;
                Collections.Generic.List<Point> PointsList = new System.Collections.Generic.List<Point>();

                while (t < 1.0)
                {
                    PointsList.Add(new Point(X.GetPosition(t), Y.GetPosition(t)));

                    t += dt;
                }

                #region アンチエイリアシング
                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    if (this.CompositingMode == CompositingMode.SourceOver)
                        this.Target.DrawPensAA(DrawPen, PointsList.ToArray(), false);

                    else
                        this.Target.CopyPensAA(DrawPen, PointsList.ToArray(), false);
                }
                #endregion

                #region エイリアシング
                else
                {
                    if (this.CompositingMode == CompositingMode.SourceOver)
                        this.Target.DrawPens(DrawPen, PointsList.ToArray(), false);

                    else
                        this.Target.CopyPens(DrawPen, PointsList.ToArray(), false);
                }
                #endregion
            }
        }
        #endregion

        #region 三角形
        /// <summary>三角形を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Point1">三角形の1つ目の頂点</param>
        /// <param name="Point2">三角形の2つ目の頂点</param>
        /// <param name="Point3">三角形の3つ目の頂点</param>
        public void DrawTriangle(Pen DrawPen, Point Point1, Point Point2, Point Point3)
        {
            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPensAA(DrawPen, new Point[] { Point1, Point2, Point3 }, true);

                else
                    this.Target.CopyPensAA(DrawPen, new Point[] { Point1, Point2, Point3 }, true);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPens(DrawPen, new Point[] { Point1, Point2, Point3 }, true);

                else
                    this.Target.CopyPens(DrawPen, new Point[] { Point1, Point2, Point3 }, true);
            }
            #endregion
        }

        /// <summary>塗りつぶしの三角形を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Point1">三角形の1つ目の頂点</param>
        /// <param name="Point2">三角形の2つ目の頂点</param>
        /// <param name="Point3">三角形の3つ目の頂点</param>
        public void FillTriangle(BaseBrush FillBrush, Point Point1, Point Point2, Point Point3)
        {
            if (Point1.X.PluralEquals(Point2.X, Point3.X))
                return;

            if (Point1.Y.PluralEquals(Point2.Y, Point3.Y))
                return;

            Point[] P = new Point[3] { Point1, Point2, Point3 };
            double MinY, MaxY, MinX, MaxX;
            int MinIndex, MaxIndex, MiddleIndex;

            MinY = P[MinIndex = 0].Y;
            MaxY = P[MaxIndex = 0].Y;
            MinX = P[0].X;
            MaxX = P[0].X;
            MiddleIndex = 0;

            for (int i = 1; i < P.Length; i++)
            {
                if (MinY > P[i].Y) MinY = P[MinIndex = i].Y;
                if (MaxY < P[i].Y) MaxY = P[MaxIndex = i].Y;
                if (MinX > P[i].X) MinX = P[i].X;
                if (MaxX < P[i].X) MaxX = P[i].X;
            }

            for (int i = 0; i < P.Length; i++)
            {
                if (MinIndex != i && MaxIndex != i)
                {
                    MiddleIndex = i;
                    break;
                }
            }

            if (MaxY < 0 || MaxX < 0) return;
            if (MinY >= this.Target.PixelHeight || MinX >= this.Target.PixelWidth) return;

            #region 前準備
            int iMinY, iMaxY;
            int fixLX, fixRX;
            iMinY = (int)Math.Floor(MinY);
            iMaxY = ((int)MaxY).MaxClipping(this.Target.PixelHeight - 1);
            fixLX = fixRX = P[MinIndex].X.ToFix();
            int addL = 0, addR = 0;
            int iMiddleY = ((int)Math.Ceiling(P[MiddleIndex].Y)).MaxClipping(iMaxY);
            int iMaxX = this.Target.PixelWidth.ToFix();
            int destMinMiddle = (P[MinIndex].Y != P[MiddleIndex].Y ? ((P[MiddleIndex].X - P[MinIndex].X) / (P[MiddleIndex].Y - P[MinIndex].Y)).ToFix() : int.MaxValue);
            int destMiddleMax = (P[MiddleIndex].Y != P[MaxIndex].Y ? ((P[MaxIndex].X - P[MiddleIndex].X) / (P[MaxIndex].Y - P[MiddleIndex].Y)).ToFix() : int.MaxValue);
            int destMinMax = ((P[MaxIndex].X - P[MinIndex].X) / (P[MaxIndex].Y - P[MinIndex].Y)).ToFix();

            if (iMaxY <= 0) return;

            if (destMinMax < destMinMiddle)
            {
                addL = destMinMax;
                if (P[MinIndex].Y != P[MiddleIndex].Y) addR = destMinMiddle;
                else
                {
                    addR = destMiddleMax;
                    fixRX = P[MiddleIndex].X.ToFix();
                }

                if (iMinY < 0)
                {
                    int over = Math.Abs(iMinY);
                    fixLX += addL * over;

                    if (iMiddleY < 0)
                    {
                        fixRX = P[MiddleIndex].X.ToFix();
                        addR = destMiddleMax;
                        fixRX += addR * Math.Abs(iMiddleY);
                        iMiddleY = iMaxY;
                    }

                    else
                        fixRX += addR * over;

                    iMinY = 0;
                }
            }

            else
            {
                addR = destMinMax;
                if (P[MinIndex].Y != P[MiddleIndex].Y) addL = destMinMiddle;
                else
                {
                    addL = destMiddleMax;
                    fixLX = P[MiddleIndex].X.ToFix();
                }

                if (iMinY < 0)
                {
                    int over = Math.Abs(iMinY);
                    fixRX += addR * over;

                    if (iMiddleY < 0)
                    {
                        fixLX = P[MiddleIndex].X.ToFix();
                        addL = destMiddleMax;
                        fixLX += addL * Math.Abs(iMiddleY);
                        iMiddleY = iMaxY;
                    }

                    else
                        fixLX += addL * over;

                    iMinY = 0;
                }
            }

            if (P[MinIndex].Y == P[MiddleIndex].Y && iMiddleY != iMaxY)
            {
                iMiddleY = iMaxY;

                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    if (FillBrush.BrushType != BrushType.SolidColorBrush)
                    {
                        Func<int, int, int> basetmp;

                        if (FillBrush.BrushType == BrushType.HatchBrush)
                            basetmp = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                        else
                            basetmp = FillBrush.GetPixelImage;

                        Func<int, int, int> tmp = (int X, int Y) => { return basetmp(X, Y).NewBlendArgb(((byte)(255 * MinY.Modf())).Not()); };

                        if (this.CompositingMode == CompositingMode.SourceOver)
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMinY, tmp);

                        else
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMinY, tmp);
                    }

                    else
                    {
                        int NewARGB = FillBrush.GetPixelSolid().NewBlendArgb(((byte)(255 * MinY.Modf())).Not());
                        byte[] NewBARGB = NewARGB.CalcAlphaBlend();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMinY, NewARGB, NewBARGB);

                        else
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMinY, NewARGB);
                    }

                    iMinY++;
                }
            }
            #endregion

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region アンチエイリアシング
                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                        }
                    }
                    #endregion

                    if (P[MiddleIndex].Y == MaxY && (++iMaxY) <= this.Target.PixelHeight - 1)
                    {
                        Func<int, int, int> tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb((byte)(255 * MaxY.Modf())); };

                        if (this.CompositingMode == CompositingMode.SourceOver)
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMaxY, tmp);

                        else
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMaxY, tmp);
                    }
                }
                #endregion

                #region エイリアシング
                else
                {
                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region アンチエイリアシング
                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB, BARGB);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB, BARGB);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB, BARGB);
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB);
                        }
                    }
                    #endregion

                    if (P[MiddleIndex].Y == MaxY && (++iMaxY) <= this.Target.PixelHeight - 1)
                    {
                        int NewARGB = ARGB.NewArgb((byte)((byte)(255 * MaxY.Modf()) * BARGB[0] >> 8));
                        byte[] NewBARGB = NewARGB.CalcAlphaBlend();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                            this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMaxY, NewARGB, NewBARGB);

                        else
                            this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), iMaxY, NewARGB);
                    }
                }
                #endregion

                #region エイリアシング
                else
                {
                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, BARGB);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, BARGB);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, BARGB);
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iMinY != iMiddleY)
                        {
                            this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, ARGB);
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }

                        if (iMinY != iMaxY && P[MiddleIndex].Y != P[MaxIndex].Y)
                            if (destMinMax < destMinMiddle) addR = destMiddleMax; else addL = destMiddleMax;

                        this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, ARGB);

                        while (iMinY != iMaxY)
                        {
                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                            this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, ARGB);
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region 四角形
        /// <summary>長方形を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Rectangle">描画する長方形の幅・高さ・原点座標</param>
        public void DrawRectangle(Pen DrawPen, Rect Rectangle)
        {
            DrawRectangle(DrawPen, Rectangle.Left, Rectangle.Top, Rectangle.Width, Rectangle.Height);
        }

        /// <summary>長方形を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public void DrawRectangle(Pen DrawPen, double Left, double Top, double Width, double Height)
        {
            if (Width == 0.0 || Height == 0.0)
                return;

            if ((Left >= this.Target.PixelWidth && Width > 0) || (Left < 0 && Width < 0))
                return;

            if ((Top >= this.Target.PixelHeight && Height > 0) || (Top < 0 && Height < 0))
                return;

            double Right = Left + Width;
            double Bottom = Top + Height;

            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPensAA(DrawPen, new Point[] { new Point(Left, Top), new Point(Right, Top), new Point(Right, Bottom), new Point(Left, Bottom) }, true);

                else
                    this.Target.CopyPensAA(DrawPen, new Point[] { new Point(Left, Top), new Point(Right, Top), new Point(Right, Bottom), new Point(Left, Bottom) }, true);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPens(DrawPen, new Point[] { new Point(Left, Top), new Point(Right, Top), new Point(Right, Bottom), new Point(Left, Bottom) }, true);

                else
                    this.Target.CopyPens(DrawPen, new Point[] { new Point(Left, Top), new Point(Right, Top), new Point(Right, Bottom), new Point(Left, Bottom) }, true);
            }
            #endregion
        }

        /// <summary>塗りつぶしの長方形を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rectangle">描画する長方形の幅・高さ・原点座標</param>
        public void FillRectangle(BaseBrush FillBrush, Rect Rectangle)
        {
            FillRectangle(FillBrush, Rectangle.X, Rectangle.Y, Rectangle.Width, Rectangle.Height);
        }

        /// <summary>塗りつぶしの長方形を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public void FillRectangle(BaseBrush FillBrush, double Left, double Top, double Width, double Height)
        {
            if (Width == 0.0 || Height == 0.0)
                return;

            if ((Left >= this.Target.PixelWidth && Width > 0) || (Left < 0 && Width < 0))
                return;

            if ((Top >= this.Target.PixelHeight && Height > 0) || (Top < 0 && Height < 0))
                return;

            double Right = Left + Width;
            double Bottom = Top + Height;

            if (Left > Right)
                ExtraClass.Swap(ref Left, ref Right);

            if (Top > Bottom)
                ExtraClass.Swap(ref Top, ref Bottom);

            if (Right < 0) return;
            if (Bottom < 0) return;

            ExtraClass.MinClipping(ref Left, 0);
            ExtraClass.MaxClipping(ref Right, this.Target.PixelWidth);
            ExtraClass.MinClipping(ref Top, 0);
            ExtraClass.MaxClipping(ref Bottom, this.Target.PixelHeight);

            int iTop = (int)Top;
            int iBottom = (int)Bottom;

            if (iBottom <= 0) return;

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region アンチエイリアシング
                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    int fixLeft = Left.ToFix();
                    int fixRight = Right.ToFix();

                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        Func<int, int, int> tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb(((byte)(255 * Top.Modf())).Not()); };

                        this.Target.DrawXLineAA(fixLeft, fixRight, iTop, tmp);
                        if (iBottom != this.Target.PixelHeight)
                        {
                            tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb((byte)(255 * Bottom.Modf())); };
                            this.Target.DrawXLineAA(fixLeft, fixRight, iBottom, tmp);
                        }

                        iTop++;

                        while (iTop != iBottom)
                        {
                            this.Target.DrawXLineAA(fixLeft, fixRight, iTop, func);
                            iTop++;
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        Func<int, int, int> tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb(((byte)(255 * Top.Modf())).Not()); };

                        this.Target.CopyXLineAA(fixLeft, fixRight, iTop, tmp);
                        if (iBottom != this.Target.PixelHeight)
                        {
                            tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb((byte)(255 * Bottom.Modf())); };
                            this.Target.CopyXLineAA(fixLeft, fixRight, iBottom, tmp);
                        }

                        iTop++;

                        while (iTop != iBottom)
                        {
                            this.Target.CopyXLineAA(fixLeft, fixRight, iTop, func);
                            iTop++;
                        }
                    }
                    #endregion
                }
                #endregion

                #region エイリアシング
                else
                {
                    int iLeft = (int)Left;
                    int iRight = (int)Right;

                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iTop != iBottom)
                        {
                            this.Target.DrawXLine(iLeft, iRight, iTop, func);
                            iTop++;
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iTop != iBottom)
                        {
                            this.Target.CopyXLine(iLeft, iRight, iTop, func);
                            iTop++;
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region アンチエイリアシング
                if (this.SmoothingMode == SmoothingMode.AntiAlias)
                {
                    int fixLeft = Left.ToFix();
                    int fixRight = Right.ToFix();
                    byte Alpha = BARGB[0];

                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        int C;
                        this.Target.DrawXLineAA(fixLeft, fixRight, iTop, C = ARGB.NewArgb((byte)(((byte)(255 * Top.Modf())).Not() * Alpha >> 8)), C.CalcAlphaBlend());
                        if (iBottom != this.Target.PixelHeight) this.Target.DrawXLineAA(fixLeft, fixRight, iBottom, C = ARGB.NewArgb((byte)((byte)(255 * Bottom.Modf()) * Alpha >> 8)), C.CalcAlphaBlend());
                        iTop++;
                        while (iTop != iBottom)
                        {
                            this.Target.DrawXLineAA(fixLeft, fixRight, iTop, ARGB, BARGB);
                            iTop++;
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        this.Target.CopyXLineAA(fixLeft, fixRight, iTop, ARGB.NewArgb((byte)(((byte)(255 * Top.Modf())).Not() * Alpha >> 8)));
                        if (iBottom != this.Target.PixelHeight) this.Target.CopyXLineAA(fixLeft, fixRight, iBottom, ARGB.NewArgb((byte)((byte)(255 * Bottom.Modf()) * Alpha >> 8)));
                        iTop++;

                        while (iTop != iBottom)
                        {
                            this.Target.CopyXLineAA(fixLeft, fixRight, iTop, ARGB);
                            iTop++;
                        }
                    }
                    #endregion
                }
                #endregion

                #region エイリアシング
                else
                {
                    int iLeft = ((int)Left).Clipping(0,this.Target.PixelWidth);
                    int iRight = ((int)Right).Clipping(0,this.Target.PixelWidth);

                    #region ブレンド
                    if (this.CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iTop != iBottom)
                        {
                            this.Target.DrawXLine(iLeft, iRight, iTop, BARGB);
                            iTop++;
                        }
                    }
                    #endregion

                    #region コピー
                    else
                    {
                        while (iTop != iBottom)
                        {
                            this.Target.CopyXLine(iLeft, iRight, iTop, ARGB);
                            iTop++;
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion
        }

        /// <summary>塗りつぶしの四角形(平行四辺形)を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rect">四角形のパラメータを含んだPointRect</param>
        public void FillRectangle(BaseBrush FillBrush, PointRect Rect)
        {
            FillRectangle(FillBrush, Rect.TopLeft, Rect.BottomLeft, Rect.TopRight, Rect.BottomRight);
        }

        /// <summary>塗りつぶしの四角形(平行四辺形)を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Point1">四角形の1つ目の頂点</param>
        /// <param name="Point2">四角形の2つ目の頂点</param>
        /// <param name="Point3">四角形の3つ目の頂点</param>
        /// <param name="Point4">四角形の4つ目の頂点</param>
        public void FillRectangle(BaseBrush FillBrush, Point Point1,Point Point2,Point Point3,Point Point4)
        {
            if (Point1.X.PluralEquals(Point2.X, Point3.X, Point4.X))
                return;

            if (Point1.Y.PluralEquals(Point2.Y, Point3.Y, Point4.Y))
                return;

            Point[] P = new Point[4] { Point1, Point2, Point3, Point4 };
            iPoint[] iP = new iPoint[4] { (iPoint)Point1, (iPoint)Point2, (iPoint)Point3, (iPoint)Point4 };
            double MinY, MaxY, MinX, MaxX;
            int MinIndex, MaxIndex;
            int[] LIndex, RIndex;
            LIndex = new int[2] { 0, 1 };
            RIndex = new int[2] { 2, 3 };

            //左側の点と右側の点に分ける
            for (int i = 0; i < LIndex.Length; i++)
            {
                for (int j = 0; j < RIndex.Length; j++)
                {
                    if (P[LIndex[i]].X > P[RIndex[j]].X)
                        ExtraClass.Swap(ref LIndex[i], ref RIndex[j]);
                }
            }

            if (P[LIndex[0]].Y > P[LIndex[1]].Y)
                ExtraClass.Swap(ref LIndex[0], ref LIndex[1]);

            if (P[RIndex[0]].Y > P[RIndex[1]].Y)
                ExtraClass.Swap(ref RIndex[0], ref RIndex[1]);

            MinIndex = (P[LIndex[0]].Y < P[RIndex[0]].Y ? LIndex[0] : RIndex[0]);
            MinY = P[MinIndex].Y;

            MaxIndex = (P[LIndex[1]].Y > P[RIndex[1]].Y ? LIndex[1] : RIndex[1]);
            MaxY = P[MaxIndex].Y;

            MinX = P[(P[LIndex[0]].X < P[LIndex[1]].X ? LIndex[0] : LIndex[1])].X;
            MaxX = P[(P[RIndex[0]].X > P[RIndex[1]].X ? RIndex[0] : RIndex[1])].X;

            if (MaxY < 0 || MaxX < 0) return;
            if (MinY >= this.Target.PixelHeight || MinX >= this.Target.PixelWidth) return;

            if ((P[LIndex[1]].Y - P[LIndex[0]].Y) != (P[RIndex[1]].Y - P[RIndex[0]].Y)) return;
            if ((P[RIndex[0]].X - P[LIndex[0]].X) != (P[RIndex[1]].X - P[LIndex[1]].X)) return;

            int iMinY, iMaxY;
            int fixLX, fixRX;
            iMinY = (int)MinY;
            iMaxY = ((int)MaxY).MaxClipping(this.Target.PixelHeight);
            int addL = 0, addR = 0;
            int iMaxX = this.Target.PixelWidth.ToFix();
            int[] dest = new int[2];

            if (iP[LIndex[0]].Y == iP[RIndex[0]].Y)
            {
                if (P[LIndex[0]].Y == P[RIndex[0]].Y)
                    dest[0] = int.MaxValue;

                else
                    dest[0] = (P[RIndex[0]].X - P[LIndex[0]].X).ToFix() * (P[RIndex[0]].Y - P[LIndex[0]].Y < 0 ? -1 : 1);
            }

            else
                dest[0] = ((P[RIndex[0]].X - P[LIndex[0]].X) / (double)(iP[RIndex[0]].Y - iP[LIndex[0]].Y)).ToFix();

            if (iP[LIndex[0]].Y == iP[LIndex[1]].Y)
            {
                if (P[LIndex[0]].Y == P[LIndex[1]].Y)
                    dest[1] = int.MaxValue;

                else
                    dest[1] = (P[LIndex[1]].X - P[LIndex[0]].X).ToFix() * (P[LIndex[1]].Y - P[LIndex[0]].Y < 0 ? -1 : 1);
            }

            else
                dest[1] = ((P[LIndex[1]].X - P[LIndex[0]].X) / (double)(iP[LIndex[1]].Y - iP[LIndex[0]].Y)).ToFix();

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region 傾きなしの平行四辺形
                if (iP[LIndex[0]].Y == iP[RIndex[0]].Y)
                {
                    int addX = dest[1];
                    if (iMinY < 0) iMinY = 0;

                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        fixLX = P[LIndex[0]].X.ToFix();
                        fixRX = P[RIndex[0]].X.ToFix();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            Func<int, int, int> tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb(((byte)(255 * MinY.Modf())).Not()); };

                            this.Target.DrawXLineAA(fixLX, fixRX, iMinY, tmp);

                            if (iMaxY != this.Target.PixelHeight)
                            {
                                tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb((byte)(255 * MaxY.Modf())); };
                                this.Target.DrawXLineAA(fixLX, fixRX, iMaxY, tmp);
                            }

                            fixLX += addX;
                            fixRX += addX;
                            iMinY++;

                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addX, addX, iMinY, func);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }

                        else
                        {
                            Func<int, int, int> tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb(((byte)(255 * MinY.Modf())).Not()); };

                            this.Target.CopyXLineAA(fixLX, fixRX, iMinY, tmp);

                            if (iMaxY != this.Target.PixelHeight)
                            {
                                tmp = (int X, int Y) => { return func(X, Y).NewBlendArgb((byte)(255 * MaxY.Modf())); };
                                this.Target.CopyXLineAA(fixLX, fixRX, iMaxY, tmp);
                            }

                            fixLX += addX;
                            fixRX += addX;
                            iMinY++;

                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addX, addX, iMinY, func);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        fixLX = P[LIndex[0]].X.ToFix();
                        fixRX = P[RIndex[0]].X.ToFix();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion

                #region 平行四辺形
                else
                {
                    int destR, destL;
                    fixLX = fixRX = P[MinIndex].X.ToFix();

                    if (P[LIndex[0]].Y > P[RIndex[0]].Y)
                    {
                        addL = dest[0];
                        addR = dest[1];
                        destL = 1;
                        destR = 0;

                        if (iMinY < 0)
                        {
                            int over = Math.Abs(iMinY);

                            if (P[LIndex[1]].Y < 0)
                            {
                                over = iP[LIndex[1]].Y - iMinY;
                                fixLX += addL * over;
                                addL = dest[1];
                                fixLX += addL * Math.Abs(iP[LIndex[1]].Y);
                            }

                            else
                                fixLX += addL * over;

                            if (P[RIndex[1]].Y < 0)
                            {
                                over = iP[RIndex[1]].Y - iMinY;
                                fixRX += addR * over;
                                addR = dest[0];
                                fixRX += addR * Math.Abs(iP[RIndex[1]].Y);
                            }

                            else
                                fixRX += addR * over;

                            iMinY = 0;
                        }
                    }

                    else
                    {
                        addL = dest[1];
                        addR = dest[0];
                        destL = 0;
                        destR = 1;

                        if (iMinY < 0)
                        {
                            int over = Math.Abs(iMinY);

                            if (P[LIndex[1]].Y < 0)
                            {
                                over = iP[LIndex[1]].Y - iMinY;
                                fixLX += addL * over;
                                addL = dest[0];
                                fixLX += addL * Math.Abs(iP[LIndex[1]].Y);
                            }

                            else
                                fixLX += addL * over;

                            if (P[RIndex[1]].Y < 0)
                            {
                                over = iP[RIndex[1]].Y - iMinY;
                                fixRX += addR * over;
                                addR = dest[1];
                                fixRX += addR * Math.Abs(iP[RIndex[1]].Y);
                            }

                            else
                                fixRX += addR * over;

                            iMinY = 0;
                        }
                    }

                    if (iMinY == iP[LIndex[destR]].Y)
                    {
                        fixLX = P[LIndex[destR]].X.ToFix();
                        addL = dest[destL];
                    }

                    if (iMinY == iP[RIndex[destL]].Y)
                    {
                        fixRX = P[RIndex[destL]].X.ToFix();
                        addR = dest[destR];
                    }

                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, func);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, func);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == (int)P[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == (int)P[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region 傾きなしの平行四辺形
                if (iP[LIndex[0]].Y == iP[RIndex[0]].Y)
                {
                    int addX = dest[1];
                    if (iMinY < 0) iMinY = 0;

                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        fixLX = P[LIndex[0]].X.ToFix();
                        fixRX = P[RIndex[0]].X.ToFix();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            int C;
                            this.Target.DrawXLineAA(fixLX, fixRX, iMinY, C = ARGB.NewArgb((byte)(((byte)(255 * MinY.Modf())).Not() * BARGB[0] >> 8)), C.CalcAlphaBlend());
                            if (iMaxY != this.Target.PixelHeight) this.Target.DrawXLineAA(fixLX, fixRX, iMaxY, C = ARGB.NewArgb((byte)((byte)(255 * MaxY.Modf()) * BARGB[0] >> 8)), C.CalcAlphaBlend());

                            fixLX += addX;
                            fixRX += addX;
                            iMinY++;

                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addX, addX, iMinY, ARGB, BARGB);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }

                        else
                        {
                            this.Target.CopyXLineAA(fixLX, fixRX, iMinY, ARGB.NewArgb((byte)(((byte)(255 * MinY.Modf())).Not() * BARGB[0] >> 8)));
                            if (iMaxY != this.Target.PixelHeight) this.Target.CopyXLineAA(fixLX, fixRX, iMaxY, ARGB.NewArgb((byte)((byte)(255 * MaxY.Modf()) * BARGB[0] >> 8)));

                            fixLX += addX;
                            fixRX += addX;
                            iMinY++;

                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addX, addX, iMinY, ARGB);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        fixLX = P[LIndex[0]].X.ToFix();
                        fixRX = P[RIndex[0]].X.ToFix();

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, BARGB);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, ARGB);
                                fixLX += addX;
                                fixRX += addX;
                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion

                #region 平行四辺形
                else
                {
                    int destR, destL;
                    fixLX = fixRX = P[MinIndex].X.ToFix();

                    if (P[LIndex[0]].Y > P[RIndex[0]].Y)
                    {
                        addL = dest[0];
                        addR = dest[1];
                        destL = 1;
                        destR = 0;

                        if (iMinY < 0)
                        {
                            int over = Math.Abs(iMinY);

                            if (P[LIndex[1]].Y < 0)
                            {
                                over = iP[LIndex[1]].Y - iMinY;
                                fixLX += addL * over;
                                addL = dest[1];
                                fixLX += addL * Math.Abs(iP[LIndex[1]].Y);
                            }

                            else
                                fixLX += addL * over;

                            if (P[RIndex[1]].Y < 0)
                            {
                                over = iP[RIndex[1]].Y - iMinY;
                                fixRX += addR * over;
                                addR = dest[0];
                                fixRX += addR * Math.Abs(iP[RIndex[1]].Y);
                            }

                            else
                                fixRX += addR * over;

                            iMinY = 0;
                        }
                    }

                    else
                    {
                        addL = dest[1];
                        addR = dest[0];
                        destL = 0;
                        destR = 1;

                        if (iMinY < 0)
                        {
                            int over = Math.Abs(iMinY);

                            if (P[LIndex[1]].Y < 0)
                            {
                                over = iP[LIndex[1]].Y - iMinY;
                                fixLX += addL * over;
                                addL = dest[0];
                                fixLX += addL * Math.Abs(iP[LIndex[1]].Y);
                            }

                            else
                                fixLX += addL * over;

                            if (P[RIndex[1]].Y < 0)
                            {
                                over = iP[RIndex[1]].Y - iMinY;
                                fixRX += addR * over;
                                addR = dest[1];
                                fixRX += addR * Math.Abs(iP[RIndex[1]].Y);
                            }

                            else
                                fixRX += addR * over;

                            iMinY = 0;
                        }
                    }

                    if (iMinY == iP[LIndex[destR]].Y)
                    {
                        fixLX = P[LIndex[destR]].X.ToFix();
                        addL = dest[destL];
                    }

                    if (iMinY == iP[RIndex[destL]].Y)
                    {
                        fixRX = P[RIndex[destL]].X.ToFix();
                        addR = dest[destR];
                    }

                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB, BARGB);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, BARGB);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                this.Target.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Clipping(0, iMaxX).iPart(), iMinY, ARGB);
                                fixLX += addL;
                                fixRX += addR;
                                iMinY++;

                                if (iMinY == iP[LIndex[destR]].Y) addL = dest[destL];
                                if (iMinY == iP[RIndex[destL]].Y) addR = dest[destR];
                            }
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region 多角形
        /// <summary>多角形を書く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">オブジェクトを形作る複数の頂点</param>
        public void DrawPolygon(Pen DrawPen, Point[] Points)
        {
            if (Points.Length < 3)
                return;

            #region アンチエイリアシング
            if (this.SmoothingMode == SmoothingMode.AntiAlias)
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPensAA(DrawPen, Points, true);

                else
                    this.Target.CopyPensAA(DrawPen, Points, true);
            }
            #endregion

            #region エイリアシング
            else
            {
                if (this.CompositingMode == CompositingMode.SourceOver)
                    this.Target.DrawPens(DrawPen, Points, true);

                else
                    this.Target.CopyPens(DrawPen, Points, true);
            }
            #endregion
        }

        /// <summary>多角形を書く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">オブジェクトを形作る複数の頂点</param>
        /// <param name="Mode">辺が交差した時の塗りつぶしの方式</param>
        public void FillPolygon(BaseBrush FillBrush, Point[] Points, FillMode Mode)
        {
            if (Points.Length < 3)
                return;

            double MinY, MaxY, MinX, MaxX;
            int MinIndex, MaxIndex;

            MinY = Points[MinIndex = 0].Y;
            MaxY = Points[MaxIndex = 0].Y;
            MinX = Points[0].X;
            MaxX = Points[0].X;

            for (int i = 1; i < Points.Length; i++)
            {
                if (MinY > Points[i].Y) MinY = Points[MinIndex = i].Y;
                if (MaxY < Points[i].Y) MaxY = Points[MaxIndex = i].Y;
                if (MinX > Points[i].X) MinX = Points[i].X;
                if (MaxX < Points[i].X) MaxX = Points[i].X;
            }

            if (MaxY < 0 || MaxX < 0) return;
            if (MinY >= this.Target.PixelHeight || MinX >= this.Target.PixelWidth) return;

            System.Collections.Generic.List<FixLine> SideList = new System.Collections.Generic.List<FixLine>(Points.Length);
            int tmp;
            for (int i = 0; i < Points.Length; i++)
            {
                tmp = i + 1; if (tmp >= Points.Length) tmp = 0;
                SideList.Add(FixLine.FromXLine(Points[i], Points[tmp], FixPointConstants.FixX));
            }

            FixLineCalc Calc = new FixLineCalc(SideList);
            Calc.Clipping(0, this.Target.PixelHeight - 1);

            int iMinY, iMaxY;
            iMinY = (int)Math.Floor(MinY).MinClipping(0);
            iMaxY = ((int)Math.Ceiling(MaxY)).MaxClipping(this.Target.PixelHeight);
            int iMaxX = this.Target.PixelWidth.ToFix();

            if (iMaxY <= 0) return;

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region 奇遇規則アルゴリズム
                if (Mode == FillMode.Alternate)
                {
                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        Collections.Generic.List<PluralsValue<int, int>> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, func);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, func);

                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        Collections.Generic.List<int> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, func);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, func);

                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion

                #region 非ゼロ回転数規則アルゴリズム
                else
                {
                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        Collections.Generic.List<PluralsValue<int, int>> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, func);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, func);

                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        Collections.Generic.List<int> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, func);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, func);

                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region 奇遇規則アルゴリズム
                if (Mode == FillMode.Alternate)
                {
                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        Collections.Generic.List<PluralsValue<int, int>> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB, BARGB);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB);

                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        Collections.Generic.List<int> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, BARGB);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.NowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, ARGB);

                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion

                #region 非ゼロ回転数規則アルゴリズム
                else
                {
                    #region アンチエイリアシング
                    if (this.SmoothingMode == SmoothingMode.AntiAlias)
                    {
                        Collections.Generic.List<PluralsValue<int, int>> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB, BARGB);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLineAA(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB);

                                iMinY++;
                            }
                        }
                    }
                    #endregion

                    #region エイリアシング
                    else
                    {
                        Collections.Generic.List<int> FixX;

                        if (this.CompositingMode == CompositingMode.SourceOver)
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.DrawXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, BARGB);

                                iMinY++;
                            }
                        }

                        else
                        {
                            while (iMinY != iMaxY)
                            {
                                FixX = Calc.RollNowLine(iMinY);

                                for (int i = 0; i < FixX.Count; i += 2)
                                    this.Target.CopyXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, ARGB);

                                iMinY++;
                            }
                        }
                    }
                    #endregion
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region シェイプ
        /// <summary>シェイプを描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は3n:nはベジエ曲線の数)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が6未満か点の数が期待する倍数(3n)にならない場合に発生</exception>
        public void DrawShape(Pen DrawPen, Point[] Points)
        {
            if (Points.Length < 6 || Points.Length % 3 != 0)
                throw new ArgumentOutOfRangeException("Points", "点の数が最低値に足りないか点の数が 3n になりません。");

            Point[] Polygon = Bezier.CreatePolygon(Points, 10);

            DrawPolygon(DrawPen, Polygon);
        }

        /// <summary>塗りつぶしのシェイプを描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は3n:nはベジエ曲線の数)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が6未満か点の数が期待する倍数(3n)にならない場合に発生</exception>
        public void FillShape(BaseBrush FillBrush, Point[] Points)
        {
            if (Points.Length < 6 || Points.Length % 3 != 0)
                throw new ArgumentOutOfRangeException("Points", "点の数が最低値に足りないか点の数が 3n になりません。");

            Point[] Polygon = Bezier.CreatePolygon(Points, 5);

            FillPolygon(FillBrush, Polygon, FillMode.Alternate);
        }
        #endregion

        #region 楕円
        /// <summary>楕円を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Rect">楕円を描く長方形のパラメータを収めたRect</param>
        public void DrawEllipse(Pen DrawPen, Rect Rect)
        {
            DrawEllipse(DrawPen, Rect.Left, Rect.Top, Rect.Width, Rect.Height);
        }

        /// <summary>楕円を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public void DrawEllipse(Pen DrawPen, double Left, double Top, double Width, double Height)
        {
            int ARGB = DrawPen.Color.ToArgb();
            byte[] BARGB = ARGB.CalcAlphaBlend();

            double d2;
            double r = DrawPen.Width / 2.0;

            if (Width <= 0) return;
            if (Height <= 0) return;

            if (Left - r > this.Target.PixelWidth) return;
            if (Top - r > this.Target.PixelHeight) return;

            if (Left + r <= -Width) return;
            if (Top + r <= -Height) return;

            #region 座標を求める
            double a0 = Width / 2.0;
            double b0 = Height / 2.0;
            int x0 = (int)(Left + a0);
            int y0 = (int)(Top + b0);

            double a = a0 + r;
            double b = b0 + r;
            double a2 = a * a;
            double b2 = b * b;

            int x = 0;
            int y = (int)b;

            int[,] Circle = new int[4, y + 1];

            double dll = b2 - a2 * b + 0.25 * a2;

            Circle[0, y] = x0 - x;
            Circle[3, y] = x0 + x;

            while (a2 * (y - 0.5) > b2 * (x + 1))
            {
                if (dll < 0)
                    dll += b2 * (2 * x + 3);

                else
                {
                    dll += b2 * (2 * x + 3) + a2 * (-2 * y + 2);
                    y--;
                }

                x++;

                Circle[0, y] = x0 - x;
                Circle[3, y] = x0 + x;
            }

            d2 = b2 * (x + 0.5) * (x + 0.5) + a2 * (y - 1) * (y - 1) - a2 * b2;

            while (y > 0)
            {
                if (d2 < 0)
                {
                    d2 += b2 * (2 * x + 2) + a2 * (-2 * y + 3);
                    x++;
                }

                else
                    d2 += a2 * (-2 * y + 3);

                y--;

                Circle[0, y] = x0 - x;
                Circle[3, y] = x0 + x;
            }

            a = a0 - r;
            b = b0 - r;
            a2 = a * a;
            b2 = b * b;

            x = 0;
            y = (int)b;
            int MinCircleR = y + 1;
            dll = b2 - a2 * b + 0.25 * a2;

            Circle[1, y] = x0 - x;
            Circle[2, y] = x0 + x;

            while (a2 * (y - 0.5) > b2 * (x + 1))
            {
                if (dll < 0)
                    dll += b2 * (2 * x + 3);

                else
                {
                    dll += b2 * (2 * x + 3) + a2 * (-2 * y + 2);
                    y--;

                    Circle[1, y] = x0 - x;
                    Circle[2, y] = x0 + x;
                }

                x++;
            }

            d2 = b2 * (x + 0.5) * (x + 0.5) + a2 * (y - 1) * (y - 1) - a2 * b2;

            while (y > 0)
            {
                if (d2 < 0)
                {
                    d2 += b2 * (2 * x + 2) + a2 * (-2 * y + 3);
                    x++;
                }

                else
                    d2 += a2 * (-2 * y + 3);

                y--;

                Circle[1, y] = x0 - x;
                Circle[2, y] = x0 + x;
            }
            #endregion

            #region ブレンド
            if (this.CompositingMode == CompositingMode.SourceOver)
            {
                if (y0.InRange(0, this.Target.PixelHeight - 1))
                {
                    if (Circle[1, 0] >= 0) this.Target.DrawXLine(Circle[0, 0].MinClipping(0), Circle[1, 0], y0, BARGB);
                    if (Circle[2, 0] < this.Target.PixelWidth) this.Target.DrawXLine(Circle[2, 0], Circle[3, 0].MaxClipping(this.Target.PixelWidth), y0, BARGB);
                }

                for (int i = 1; i < MinCircleR; i++)
                {
                    if ((y0 - i).InRange(0, this.Target.PixelHeight - 1))
                    {
                        if (Circle[1, i] >= 0) this.Target.DrawXLine(Circle[0, i].MinClipping(0), Circle[1, i], y0 - i, BARGB);
                        if (Circle[2, i] < this.Target.PixelWidth) this.Target.DrawXLine(Circle[2, i], Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 - i, BARGB);
                    }

                    if ((y0 + i).InRange(0, this.Target.PixelHeight - 1))
                    {
                        if (Circle[1, i] >= 0) this.Target.DrawXLine(Circle[0, i].MinClipping(0), Circle[1, i], y0 + i, BARGB);
                        if (Circle[2, i] < this.Target.PixelWidth) this.Target.DrawXLine(Circle[2, i], Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 + i, BARGB);
                    }
                }

                for (int i = MinCircleR; i < Circle.Length >> 2; i++)
                {
                    if ((y0 - i).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine(Circle[0, i].MinClipping(0), Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 - i, BARGB);
                    if ((y0 + i).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine(Circle[0, i].MinClipping(0), Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 + i, BARGB);
                }
            }
            #endregion

            #region コピー
            else
            {
                if (y0.InRange(0, this.Target.PixelHeight - 1))
                {
                    if (Circle[1, 0] >= 0) this.Target.CopyXLine(Circle[0, 0].MinClipping(0), Circle[1, 0], y0, ARGB);
                    if (Circle[2, 0] < this.Target.PixelWidth) this.Target.CopyXLine(Circle[2, 0], Circle[3, 0].MaxClipping(this.Target.PixelWidth), y0, ARGB);
                }

                for (int i = 1; i < MinCircleR; i++)
                {
                    if ((y0 - i).InRange(0, this.Target.PixelHeight - 1))
                    {
                        if (Circle[1, i] >= 0) this.Target.CopyXLine(Circle[0, i].MinClipping(0), Circle[1, i], y0 - i, ARGB);
                        if (Circle[2, i] < this.Target.PixelWidth) this.Target.CopyXLine(Circle[2, i], Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 - i, ARGB);
                    }

                    if ((y0 + i).InRange(0, this.Target.PixelHeight - 1))
                    {
                        if (Circle[1, i] >= 0) this.Target.CopyXLine(Circle[0, i].MinClipping(0), Circle[1, i], y0 + i, ARGB);
                        if (Circle[2, i] < this.Target.PixelWidth) this.Target.CopyXLine(Circle[2, i], Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 + i, ARGB);
                    }
                }

                for (int i = MinCircleR; i < Circle.Length >> 2; i++)
                {
                    if ((y0 - i).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine(Circle[0, i].MinClipping(0), Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 - i, ARGB);
                    if ((y0 + i).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine(Circle[0, i].MinClipping(0), Circle[3, i].MaxClipping(this.Target.PixelWidth), y0 + i, ARGB);
                }
            }
            #endregion
        }

        /// <summary>塗りつぶしの楕円を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rect">楕円を描く長方形のパラメータを収めたRect</param>
        public void FillEllipse(BaseBrush FillBrush, Rect Rect)
        {
            FillEllipse(FillBrush, Rect.Left, Rect.Top, Rect.Width, Rect.Height);
        }

        /// <summary>塗りつぶしの楕円を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public void FillEllipse(BaseBrush FillBrush, double Left, double Top, double Width, double Height)
        {
            if (Width <= 0) return;
            if (Height <= 0) return;

            if (Left > this.Target.PixelWidth) return;
            if (Top > this.Target.PixelHeight) return;

            if (Left <= -Width) return;
            if (Top <= -Height) return;

            double tmp;
            double a = (Width <= Height ? 1.0 : (tmp = Height / Width) * tmp);
            double b = (Height <= Width ? 1.0 : ((tmp = Width / Height) * tmp));
            int A2 = (int)(a * 2.0).ToFix();
            int B2 = (int)(b * 2.0).ToFix();
            int A4 = (int)(a * 4.0).ToFix();
            int B4 = (int)(b * 4.0).ToFix();

            int x0 = (int)(Left + Width / 2.0);
            int y0 = (int)(Top + Height / 2.0);

            int r = (int)(Width < Height ? Width / 2.0 : Height / 2.0);

            double RootA = Math.Sqrt((double)a);

            int x = (int)((double)r / RootA);
            int y = 1;
            double d = RootA * (double)r;
            int F = (-2.0 * d + a + 2 * b).ToFix();
            int H = (-4.0 * d + 2 * a + b).ToFix();

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region ブレンド
                if (this.CompositingMode == CompositingMode.SourceOver)
                {
                    if (y0.InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0, func);
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, func);
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, func);

                    while (x >= 0)
                    {
                        if (F >= 0)
                        {
                            --x;
                            F -= A4 * x;
                            H -= A4 * x - A2;
                        }

                        if (H < 0)
                        {
                            ++y;
                            F += B4 * y + B2;
                            H += B4 * y;

                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, func);
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, func);
                        }
                    }
                }
                #endregion

                #region コピー
                else
                {
                    if (y0.InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0, func);
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, func);
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, func);

                    while (x >= 0)
                    {
                        if (F >= 0)
                        {
                            --x;
                            F -= A4 * x;
                            H -= A4 * x - A2;
                        }

                        if (H < 0)
                        {
                            ++y;
                            F += B4 * y + B2;
                            H += B4 * y;

                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, func);
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, func);
                        }
                    }
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region ブレンド
                if (this.CompositingMode == CompositingMode.SourceOver)
                {
                    if (y0.InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0, BARGB);
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, BARGB);
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, BARGB);

                    while (x >= 0)
                    {
                        if (F >= 0)
                        {
                            --x;
                            F -= A4 * x;
                            H -= A4 * x - A2;
                        }

                        if (H < 0)
                        {
                            ++y;
                            F += B4 * y + B2;
                            H += B4 * y;

                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, BARGB);
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.DrawXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, BARGB);
                        }
                    }
                }
                #endregion

                #region コピー
                else
                {
                    if (y0.InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0, ARGB);
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, ARGB);
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, ARGB);

                    while (x >= 0)
                    {
                        if (F >= 0)
                        {
                            --x;
                            F -= A4 * x;
                            H -= A4 * x - A2;
                        }

                        if (H < 0)
                        {
                            ++y;
                            F += B4 * y + B2;
                            H += B4 * y;

                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 + y, ARGB);
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) this.Target.CopyXLine((x0 - x).Clipping(0, this.Target.PixelWidth - 1), (x0 + x).Clipping(0, this.Target.PixelWidth), y0 - y, ARGB);
                        }
                    }
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region 円弧・扇形
        /// <summary>象限</summary>
        private enum Quadrants
        {
            /// <summary>第一象限(0&lt;θ&lt;90)</summary>
            FirstQuadrant = 1,
            /// <summary>第二象限(90&lt;θ&lt;180)</summary>
            SecondQuadrant = 2,
            /// <summary>第三象限(180&lt;θ&lt;270)</summary>
            ThirdQuadrant = 4,
            /// <summary>第四象限(270&lt;θ&lt;360)</summary>
            FourthQuadrant = 8,
        }

        /// <summary>円弧を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Rect">円弧を描く長方形のパラメータを収めたRect</param>
        /// <param name="StartAngle">X軸から円弧の開始点まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから円弧の終了点まで、時計回りに測定した角度(度単位)</param>
        public void DrawArc(Pen DrawPen, Rect Rect, double StartAngle, double EndAngle)
        {
            DrawArc(DrawPen, Rect.Left, Rect.Top, Rect.Width, Rect.Height, StartAngle, EndAngle);
        }

        /// <summary>円弧を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">円弧を描く長方形の左上端座標X</param>
        /// <param name="Top">円弧を描く長方形の左上端座標Y</param>
        /// <param name="Width">円弧を描く長方形の幅</param>
        /// <param name="Height">円弧を描く長方形の高さ</param>
        /// <param name="StartAngle">X軸から円弧の開始点まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから円弧の終了点まで、時計回りに測定した角度(度単位)</param>
        public void DrawArc(Pen DrawPen, double Left, double Top, double Width, double Height, double StartAngle, double EndAngle)
        {
            if (EndAngle == 0) return;

            if (Width <= 0) return;
            if (Height <= 0) return;

            if (Math.Abs(EndAngle) >= 360)
            {
                DrawEllipse(DrawPen, Left, Top, Width, Height);
                return;
            }

            double r = DrawPen.Width / 2.0;

            if (Left - r > this.Target.PixelWidth) return;
            if (Top - r > this.Target.PixelHeight) return;

            if (Left + r <= -Width) return;
            if (Top + r <= -Height) return;

            #region 座標を求める
            StartAngle = StartAngle.RotateClipping(0, 360);

            double degEnd = (StartAngle + EndAngle).RotateClipping(0, 360);

            if (EndAngle < 0) ExtraClass.Swap(ref StartAngle, ref degEnd);

            double SA = StartAngle * Math.PI / 180.0;
            double EA = degEnd * Math.PI / 180.0;

            int ARGB = DrawPen.Color.ToArgb();
            byte[] BARGB = ARGB.CalcAlphaBlend();

            Quadrants Quad, EndQuad, BaseQuad;

            //始点の象限を時計回りで定義する
            if (StartAngle == 360 || (0 <= StartAngle && StartAngle < 90))
                Quad = Quadrants.FirstQuadrant;

            else if (90 <= StartAngle && StartAngle < 180)
                Quad = Quadrants.SecondQuadrant;

            else if (180 <= StartAngle && StartAngle < 270)
                Quad = Quadrants.ThirdQuadrant;

            else
                Quad = Quadrants.FourthQuadrant;

            //終点の象限を時計回りで定義する
            if (0 < degEnd && degEnd <= 90)
                EndQuad = Quadrants.FirstQuadrant;

            else if (90 < degEnd && degEnd <= 180)
                EndQuad = Quadrants.SecondQuadrant;

            else if (180 < degEnd && degEnd <= 270)
                EndQuad = Quadrants.ThirdQuadrant;

            else
                EndQuad = Quadrants.FourthQuadrant;

            BaseQuad = Quad;

            double A0 = Width / 2.0;
            double B0 = Height / 2.0;
            int x0 = (int)(Left + A0);
            int y0 = (int)(Top + B0);

            double A = A0 + r;
            double B = B0 + r;

            Collections.Generic.List<int>[] Circle = new System.Collections.Generic.List<int>[this.Target.PixelHeight];

            for (int i = 0; i < Circle.Length; i++)
                Circle[i] = new System.Collections.Generic.List<int>();

            double tmp;

            double a = (Width <= Height ? 1.0 : ((tmp = B / A) * (tmp)));
            double b = (Height <= Width ? 1.0 : ((tmp = A / B) * (tmp)));
            int A2 = (a * 2.0).ToFix();
            int B2 = (b * 2.0).ToFix();
            int A4 = (a * 4.0).ToFix();
            int B4 = (b * 4.0).ToFix();

            iPoint SP = new iPoint((int)(A * Math.Cos(SA)), (int)(B * Math.Sin(SA)));
            iPoint EP = new iPoint((int)(A * Math.Cos(EA)), (int)(B * Math.Sin(EA)));
            int x = Math.Abs(SP.X);
            int y = Math.Abs(SP.Y);
            int ex = Math.Abs(EP.X);
            int ey = Math.Abs(EP.Y);
            bool Add;

            int F = -A2 * x + B4 * y + B2 + a.ToFix();

            bool EndFlag = (ey * b) < (ex * a);

            if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                Add = true;
            }

            else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                Add = false;
            }

            else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                Add = true;
            }

            else
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                Add = false;
            }

            //外枠のXを求める
            while (!(((Quad & EndQuad) != 0) && (EndFlag ? y == ey : x == ex)))
            {
                if (F >= 0 && ((Add && x == 0) || (!Add && y == 0)))
                {
                    if ((Quad & Quadrants.FourthQuadrant) == Quadrants.FourthQuadrant)
                        Quad = Quadrants.FirstQuadrant;

                    else
                        Quad = (Quadrants)((int)Quad << 1);

                    Add = !Add;

                    if (x == 0)
                    {
                        x++;
                        F -= A4 * x;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 - x);
                        }

                        else
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 + x);
                        }

                        y++;
                    }
                }

                if (Add)
                {
                    if (F >= 0)
                    {
                        x--;
                        F -= A4 * x;
                    }

                    else
                    {
                        y++;
                        F += B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                    }
                }

                else
                {
                    if (F < 0)
                    {
                        F += A4 * x;
                        x++;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);

                        y--;
                    }
                }
            }

            if (!Add)
            {
                if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                }

                else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                }

                else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                {
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                }

                else
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
            }

            EP.X = (EP.X < 0 ? -x : x);
            EP.Y = (EP.Y < 0 ? -y : y);

            Quad = BaseQuad;

            A = A0 - r;
            B = B0 - r;

            a = (Width <= Height ? 1.0 : ((tmp = B / A) * (tmp)));
            b = (Height <= Width ? 1.0 : ((tmp = A / B) * (tmp)));
            A2 = (a * 2.0).ToFix();
            B2 = (b * 2.0).ToFix();
            A4 = (a * 4.0).ToFix();
            B4 = (b * 4.0).ToFix();

            iPoint SP2 = new iPoint((int)(A * Math.Cos(SA)), (int)(B * Math.Sin(SA)));
            iPoint EP2 = new iPoint((int)(A * Math.Cos(EA)), (int)(B * Math.Sin(EA)));
            x = Math.Abs(SP2.X);
            y = Math.Abs(SP2.Y);
            ex = Math.Abs(EP2.X);
            ey = Math.Abs(EP2.Y);

            F = -A2 * x + B4 * y + B2 + a.ToFix();

            if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                Add = true;
            }

            else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                Add = false;
            }

            else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                Add = true;
            }

            else
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                Add = false;
            }

            //内枠のXを求める
            while (!(((Quad & EndQuad) != 0) && (EndFlag ? y == ey : x == ex)))
            {
                if (F >= 0 && ((Add && x == 0) || (!Add && y == 0)))
                {
                    if ((Quad & Quadrants.FourthQuadrant) == Quadrants.FourthQuadrant)
                        Quad = Quadrants.FirstQuadrant;

                    else
                        Quad = (Quadrants)((int)Quad << 1);

                    Add = !Add;

                    if (x == 0)
                    {
                        x++;
                        F -= A4 * x;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 - x);
                        }

                        else
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 + x);
                        }

                        y++;
                    }
                }

                if (Add)
                {
                    if (F >= 0)
                    {
                        x--;

                        F -= A4 * x;
                    }

                    else
                    {
                        y++;

                        F += B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                    }
                }

                else
                {
                    if (F < 0)
                    {
                        F += A4 * x;
                        x++;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                   
                        y--;
                    }
                }
            }

            if (!Add)
            {
                if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                }

                else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                }

                else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                {
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                }

                else
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
            }


            EP2.X = (EP2.X < 0 ? -x : x);
            EP2.Y = (EP2.Y < 0 ? -y : y);

            //ブツ切りの部分の斜線を求める
            if (SP.Y != SP2.Y)
            {
                int iX1 = SP.X;
                int iX2 = SP2.X;
                int iY1 = SP.Y;
                int iY2 = SP2.Y;

                int dstX, dstY;
                int addX = 1, addY = 1;
                int counter = 0;  //カウンタ

                dstX = iX2 - iX1;

                //始点から終点までの、x,yそれぞれの距離を求める
                if (dstX < 0)
                {
                    dstX = -dstX;
                    addX = -1;
                }

                dstY = iY2 - iY1;

                if (dstY < 0)
                {
                    dstY = -dstY;
                    addY = -1;
                }

                //距離を比較
                if (dstX > dstY)
                {
                    // X方向に点を打っていく
                    while (iX1 != iX2)
                    {
                        counter += dstY;
                        if (counter > dstX)
                        {
                            counter -= dstX;
                            iY1 += addY;

                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);
                        }

                        iX1 += addX;
                    }

                    if ((y0 + iY2).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY2].Add(x0 + iX1);
                }

                else
                {
                    counter += dstX;
                    iY1 += addY;

                    // Y方向に点を打っていく
                    while (iY1 != iY2)
                    {
                        if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                        counter += dstX;
                        if (counter > dstY)
                        {
                            counter -= dstY;
                            iX1 += addX;
                        }

                        iY1 += addY;
                    }

                    if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);
                }
            }

            if (EP.Y != EP2.Y)
            {
                int iX1 = EP.X;
                int iX2 = EP2.X;
                int iY1 = EP.Y;
                int iY2 = EP2.Y;

                int dstX, dstY;
                int addX = 1, addY = 1;
                int counter = 0;  //カウンタ

                dstX = iX2 - iX1;

                //始点から終点までの、x,yそれぞれの距離を求める
                if (dstX < 0)
                {
                    dstX = -dstX;
                    addX = -1;
                }

                dstY = iY2 - iY1;

                if (dstY < 0)
                {
                    dstY = -dstY;
                    addY = -1;
                }

                //距離を比較
                if (dstX > dstY)
                {
                    // X方向に点を打っていく
                    while (iX1 != iX2)
                    {
                        counter += dstY;
                        if (counter > dstX)
                        {
                            counter -= dstX;
                            iY1 += addY;

                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);
                        }

                        iX1 += addX;
                    }

                    if ((y0 + iY2).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY2].Add(x0 + iX1);
                }

                else
                {
                    counter += dstX;
                    iY1 += addY;

                    // Y方向に点を打っていく
                    while (iY1 != iY2)
                    {
                        if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                        counter += dstX;
                        if (counter > dstY)
                        {
                            counter -= dstY;
                            iX1 += addX;
                        }

                        iY1 += addY;
                    }

                    if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);
                }
            }
            #endregion

            #region ブレンド
            if (this.CompositingMode == CompositingMode.SourceOver)
            {
                for (int i = 0; i < Circle.Length; i++)
                {
                    Circle[i].Sort();

                    if (Circle[i].Count == 0)
                        continue;

                    for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                        this.Target.DrawXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, BARGB);
                }
            }
            #endregion

            #region コピー
            else
            {
                for (int i = 0; i < Circle.Length; i++)
                {
                    Circle[i].Sort();

                    if (Circle[i].Count == 0)
                        continue;

                    for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                        this.Target.CopyXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, ARGB);
                }
            }
            #endregion
        }

        /// <summary>扇形を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Rect">扇形を描く長方形のパラメータを収めたRect</param>
        /// <param name="StartAngle">X軸から扇形の最初の辺まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから扇形の二番目の辺まで、時計回りに測定した角度(度単位)</param>
        public void DrawPie(Pen DrawPen, Rect Rect, double StartAngle, double EndAngle)
        {
            DrawPie(DrawPen, Rect.Left, Rect.Top, Rect.Width, Rect.Height, StartAngle, EndAngle);
        }

        /// <summary>扇形を描く</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">扇形を描く長方形の左上端座標X</param>
        /// <param name="Top">扇形を描く長方形の左上端座標Y</param>
        /// <param name="Width">扇形を描く長方形の幅</param>
        /// <param name="Height">扇形を描く長方形の高さ</param>
        /// <param name="StartAngle">X軸から扇形の最初の辺まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから扇形の二番目の辺まで、時計回りに測定した角度(度単位)</param>
        public void DrawPie(Pen DrawPen, double Left, double Top, double Width, double Height, double StartAngle, double EndAngle)
        {
            if (EndAngle == 0) return;

            if (Width <= 0) return;
            if (Height <= 0) return;

            if (Math.Abs(EndAngle) >= 360)
            {
                DrawEllipse(DrawPen, Left, Top, Width, Height);
                return;
            }

            double r = DrawPen.Width / 2.0;

            if (Left - r > this.Target.PixelWidth) return;
            if (Top - r > this.Target.PixelHeight) return;

            if (Left + r <= -Width) return;
            if (Top + r <= -Height) return;

            #region 座標を求める
            StartAngle = StartAngle.RotateClipping(0, 360);

            double degEnd = (StartAngle + EndAngle).RotateClipping(0, 360);

            if (EndAngle < 0) ExtraClass.Swap(ref StartAngle, ref degEnd);

            double SA = StartAngle * Math.PI / 180.0;
            double EA = degEnd * Math.PI / 180.0;

            int ARGB = DrawPen.Color.ToArgb();
            byte[] BARGB = ARGB.CalcAlphaBlend();

            Quadrants Quad, EndQuad;

            double A0 = Width / 2.0;
            double B0 = Height / 2.0;
            int x0 = (int)(Left + A0);
            int y0 = (int)(Top + B0);

            double A = A0 + r;
            double B = B0 + r;

            Collections.Generic.List<int>[] Circle = new System.Collections.Generic.List<int>[this.Target.PixelHeight];

            for (int i = 0; i < Circle.Length; i++)
                Circle[i] = new System.Collections.Generic.List<int>();

            double tmp;

            double a = (Width <= Height ? 1.0 : ((tmp = B / A) * (tmp)));
            double b = (Height <= Width ? 1.0 : ((tmp = A / B) * (tmp)));
            int A2 = (a * 2.0).ToFix();
            int B2 = (b * 2.0).ToFix();
            int A4 = (a * 4.0).ToFix();
            int B4 = (b * 4.0).ToFix();

            double FX = A * Math.Cos(SA);
            double FY = B * Math.Sin(SA);
            double DeltaTheta = Math.Atan(r / Math.Sqrt(FX * FX + FY * FY));
            double DegTheta = DeltaTheta * 180.0 / Math.PI;
            double Degree = (StartAngle - DegTheta).RotateClipping(0, 360);

            if (EndAngle < DegTheta * 2.0)
            {
                FillPie(DrawPen.Brush, Left - DrawPen.Width, Top - DrawPen.Width, Width + DrawPen.Width * 2.0, Height + DrawPen.Width * 2.0, StartAngle - DegTheta, EndAngle + DegTheta * 2.0);
                return;
            }

            //始点の象限を時計回りで定義する
            if (StartAngle == 360 || (0 <= StartAngle && StartAngle < 90))
                Quad = Quadrants.FirstQuadrant;

            else if (90 <= StartAngle && StartAngle < 180)
                Quad = Quadrants.SecondQuadrant;

            else if (180 <= StartAngle && StartAngle < 270)
                Quad = Quadrants.ThirdQuadrant;

            else
                Quad = Quadrants.FourthQuadrant;

            //終点の象限を時計回りで定義する
            if (0 < degEnd && degEnd <= 90)
                EndQuad = Quadrants.FirstQuadrant;

            else if (90 < degEnd && degEnd <= 180)
                EndQuad = Quadrants.SecondQuadrant;

            else if (180 < degEnd && degEnd <= 270)
                EndQuad = Quadrants.ThirdQuadrant;

            else
                EndQuad = Quadrants.FourthQuadrant;

            double dx;
            double dy;
            Point[] OutLine = new Point[4];
            Point[] InLine = new Point[4];

            if (FY != 0)
            {
                double deltaR = -(FX / FY);
                double theta = Math.Atan(deltaR);
                dx = (Math.Cos(theta) * r).AbsCeiling();
                dy = (Math.Sin(theta) * r).AbsCeiling();
            }

            else
            {
                dx = 0;
                dy = r;
                if (FX > 0) dy = -dy;
            }

            switch (Quad)
            {
                case Quadrants.FirstQuadrant:
                case Quadrants.SecondQuadrant:
                    OutLine[1] = new Point(dx, dy);
                    InLine[1] = new Point(-dx, -dy);
                    break;

                case Quadrants.ThirdQuadrant:
                case Quadrants.FourthQuadrant:
                    OutLine[1] = new Point(-dx, -dy);
                    InLine[1] = new Point(dx, dy);
                    break;
            }

            FX = A * Math.Cos(EA);
            FY = B * Math.Sin(EA);

            if (FY != 0)
            {
                double deltaR = -(FX / FY);
                double theta = Math.Atan(deltaR);
                dx = (Math.Cos(theta) * r).AbsCeiling();
                dy = (Math.Sin(theta) * r).AbsCeiling();
            }

            else
            {
                dx = 0;
                dy = r;
                if (FX > 0) dy = -dy;
            }

            switch (EndQuad)
            {
                case Quadrants.FirstQuadrant:
                case Quadrants.SecondQuadrant:
                    OutLine[2] = new Point(-dx, -dy);
                    InLine[2] = new Point(dx, dy);
                    break;

                case Quadrants.ThirdQuadrant:
                case Quadrants.FourthQuadrant:
                    OutLine[2] = new Point(dx, dy);
                    InLine[2] = new Point(-dx, -dy);
                    break;
            }

            //始点の象限を時計回りで定義する
            if (Degree == 360 || (0 <= Degree && Degree < 90))
                Quad = Quadrants.FirstQuadrant;

            else if (90 <= Degree && Degree < 180)
                Quad = Quadrants.SecondQuadrant;

            else if (180 <= Degree && Degree < 270)
                Quad = Quadrants.ThirdQuadrant;

            else
                Quad = Quadrants.FourthQuadrant;

            Degree = (degEnd + DegTheta).RotateClipping(0, 360);

            //終点の象限を時計回りで定義する
            if (0 < Degree && Degree <= 90)
                EndQuad = Quadrants.FirstQuadrant;

            else if (90 < Degree && Degree <= 180)
                EndQuad = Quadrants.SecondQuadrant;

            else if (180 < Degree && Degree <= 270)
                EndQuad = Quadrants.ThirdQuadrant;

            else
                EndQuad = Quadrants.FourthQuadrant;

            OutLine[0] = new Point(A * Math.Cos(SA - DeltaTheta), B * Math.Sin(SA - DeltaTheta));
            OutLine[3] = new Point(A * Math.Cos(EA + DeltaTheta), B * Math.Sin(EA + DeltaTheta));

            iPoint SP = (iPoint)OutLine[0];
            iPoint EP = (iPoint)OutLine[3];
            int x = Math.Abs(SP.X);
            int y = Math.Abs(SP.Y);
            int ex = Math.Abs(EP.X);
            int ey = Math.Abs(EP.Y);
            bool Add;

            int F = -A2 * x + B4 * y + B2 + a.ToFix();

            bool EndFlag = (ey * b) < (ex * a);

            if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                Add = true;
            }

            else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                Add = false;
            }

            else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                Add = true;
            }

            else
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                Add = false;
            }

            //外枠のXを求める
            while (!(((Quad & EndQuad) != 0) && (EndFlag ? y == ey : x == ex)))
            {
                if (F >= 0 && ((Add && x == 0) || (!Add && y == 0)))
                {
                    if ((Quad & Quadrants.FourthQuadrant) == Quadrants.FourthQuadrant)
                        Quad = Quadrants.FirstQuadrant;

                    else
                        Quad = (Quadrants)((int)Quad << 1);

                    Add = !Add;

                    if (x == 0)
                    {
                        x++;
                        F -= A4 * x;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 - x);
                        }

                        else
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 + x);
                        }

                        y++;
                    }
                }

                if (Add)
                {
                    if (F >= 0)
                    {
                        x--;
                        F -= A4 * x;
                    }

                    else
                    {
                        y++;
                        F += B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                    }
                }

                else
                {
                    if (F < 0)
                    {
                        F += A4 * x;
                        x++;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);

                        y--;
                    }
                }
            }

            if (!Add)
            {
                if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                }

                else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                }

                else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                {
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                }

                else
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
            }

            EP.X = (EP.X < 0 ? -x : x);
            EP.Y = (EP.Y < 0 ? -y : y);

            OutLine[3] = EP;

            Degree = (StartAngle + DegTheta).RotateClipping(0, 360);

            //始点の象限を時計回りで定義する
            if (Degree == 360 || (0 <= Degree && Degree < 90))
                Quad = Quadrants.FirstQuadrant;

            else if (90 <= Degree && Degree < 180)
                Quad = Quadrants.SecondQuadrant;

            else if (180 <= Degree && Degree < 270)
                Quad = Quadrants.ThirdQuadrant;

            else
                Quad = Quadrants.FourthQuadrant;

            Degree = (degEnd - DegTheta).RotateClipping(0, 360);

            //終点の象限を時計回りで定義する
            if (0 < Degree && Degree <= 90)
                EndQuad = Quadrants.FirstQuadrant;

            else if (90 < Degree && Degree <= 180)
                EndQuad = Quadrants.SecondQuadrant;

            else if (180 < Degree && Degree <= 270)
                EndQuad = Quadrants.ThirdQuadrant;

            else
                EndQuad = Quadrants.FourthQuadrant;

            A = A0 - r;
            B = B0 - r;

            a = (Width <= Height ? 1.0 : ((tmp = B / A) * (tmp)));
            b = (Height <= Width ? 1.0 : ((tmp = A / B) * (tmp)));
            A2 = (a * 2.0).ToFix();
            B2 = (b * 2.0).ToFix();
            A4 = (a * 4.0).ToFix();
            B4 = (b * 4.0).ToFix();

            InLine[0] = new Point(A * Math.Cos(SA + DeltaTheta), B * Math.Sin(SA + DeltaTheta));
            InLine[3] = new Point(A * Math.Cos(EA - DeltaTheta), B * Math.Sin(EA - DeltaTheta));

            iPoint SP2 = (iPoint)InLine[0];
            iPoint EP2 = (iPoint)InLine[3];
            x = Math.Abs(SP2.X);
            y = Math.Abs(SP2.Y);
            ex = Math.Abs(EP2.X);
            ey = Math.Abs(EP2.Y);

            F = -A2 * x + B4 * y + B2 + a.ToFix();

            if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                Add = true;
            }

            else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                Add = false;
            }

            else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                Add = true;
            }

            else
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                Add = false;
            }

            //内枠のXを求める
            while (!(((Quad & EndQuad) != 0) && (EndFlag ? y == ey : x == ex)))
            {
                if (F >= 0 && ((Add && x == 0) || (!Add && y == 0)))
                {
                    if ((Quad & Quadrants.FourthQuadrant) == Quadrants.FourthQuadrant)
                        Quad = Quadrants.FirstQuadrant;

                    else
                        Quad = (Quadrants)((int)Quad << 1);

                    Add = !Add;

                    if (x == 0)
                    {
                        x++;
                        F -= A4 * x;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 - x);
                        }

                        else
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 + x);
                        }

                        y++;
                    }
                }

                if (Add)
                {
                    if (F >= 0)
                    {
                        x--;
                        F -= A4 * x;
                    }

                    else
                    {
                        y++;
                        F += B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                    }
                }

                else
                {
                    if (F < 0)
                    {
                        F += A4 * x;
                        x++;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);

                        y--;
                    }
                }
            }

            if (!Add)
            {
                if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                }

                else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                }

                else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                {
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                }

                else
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
            }

            EP2.X = (EP2.X < 0 ? -x : x);
            EP2.Y = (EP2.Y < 0 ? -y : y);

            InLine[3] = EP2;

            iPoint[] CP = new iPoint[2];
            Point[][] PList = new Point[2][] { OutLine, InLine };

            for (int i = 0; i < 2; i++)
            {
                // パラメータ表記の値に変換する
                double x1 = PList[i][0].X;
                double y1 = PList[i][0].Y;
                double f1 = PList[i][1].X - x1;
                double g1 = PList[i][1].Y - y1;
                double x2 = PList[i][2].X;
                double y2 = PList[i][2].Y;
                double f2 = PList[i][3].X - x2;
                double g2 = PList[i][3].Y - y2;

                // detの計算
                double det = f2 * g1 - f1 * g2;

                if (det == 0)
                {
                    CP[i] = (iPoint)PList[i][1];
                    continue;
                }

                // 交点におけるパラメータ
                dx = x2 - x1;
                dy = y2 - y1;
                double t1 = (f2 * dy - g2 * dx) / det;
                //t2 = (f1 * dy - g1 * dx) / det;

                // 交点の座標
                CP[i].X = (int)(x1 + f1 * t1);
                CP[i].Y = (int)(y1 + g1 * t1);
            }

            iPoint[] SPList = new iPoint[2] { SP, SP2 };
            iPoint[] EPList = new iPoint[2] { EP, EP2 };

            for (int i = 0; i < 2; i++)
            {
                //ブツ切りの部分の斜線を求める
                if (SPList[i].Y != CP[i].Y)
                {
                    int iX1 = SPList[i].X;
                    int iX2 = CP[i].X;
                    int iY1 = SPList[i].Y;
                    int iY2 = CP[i].Y;

                    int dstX, dstY;
                    int addX = 1, addY = 1;
                    int counter = 0;  //カウンタ

                    dstX = iX2 - iX1;

                    //始点から終点までの、x,yそれぞれの距離を求める
                    if (dstX < 0)
                    {
                        dstX = -dstX;
                        addX = -1;
                    }

                    dstY = iY2 - iY1;

                    if (dstY < 0)
                    {
                        dstY = -dstY;
                        addY = -1;
                    }

                    //距離を比較
                    if (dstX > dstY)
                    {
                        // X方向に点を打っていく
                        while (iX1 != iX2)
                        {
                            counter += dstY;
                            if (counter > dstX)
                            {
                                counter -= dstX;
                                iY1 += addY;

                                if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY1].Add(x0 + iX1);
                            }

                            iX1 += addX;
                        }
                    }

                    else
                    {
                        counter += dstX;
                        iY1 += addY;

                        // Y方向に点を打っていく
                        while (iY1 != iY2)
                        {
                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                            counter += dstX;
                            if (counter > dstY)
                            {
                                counter -= dstY;
                                iX1 += addX;
                            }

                            iY1 += addY;
                        }
                    }
                }

                if (EPList[i].Y != CP[i].Y)
                {
                    int iX1 = EPList[i].X;
                    int iX2 = CP[i].X;
                    int iY1 = EPList[i].Y;
                    int iY2 = CP[i].Y;

                    int dstX, dstY;
                    int addX = 1, addY = 1;
                    int counter = 0;  //カウンタ

                    dstX = iX2 - iX1;

                    //始点から終点までの、x,yそれぞれの距離を求める
                    if (dstX < 0)
                    {
                        dstX = -dstX;
                        addX = -1;
                    }

                    dstY = iY2 - iY1;

                    if (dstY < 0)
                    {
                        dstY = -dstY;
                        addY = -1;
                    }

                    //距離を比較
                    if (dstX > dstY)
                    {
                        // X方向に点を打っていく
                        while (iX1 != iX2)
                        {
                            counter += dstY;
                            if (counter > dstX)
                            {
                                counter -= dstX;
                                iY1 += addY;

                                if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY1].Add(x0 + iX1);
                            }

                            iX1 += addX;
                        }
                    }

                    else
                    {
                        counter += dstX;
                        iY1 += addY;

                        // Y方向に点を打っていく
                        while (iY1 != iY2)
                        {
                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                            counter += dstX;
                            if (counter > dstY)
                            {
                                counter -= dstY;
                                iX1 += addX;
                            }

                            iY1 += addY;
                        }
                    }
                }
            }

            if ((y0 + InLine[0].Y).InRange(0, this.Target.PixelHeight - 1) && ((Circle[y0 + (int)InLine[0].Y].Count & 1) != 0))
                Circle[y0 + (int)InLine[0].Y].Add(x0 + (int)InLine[0].X);

            if ((y0 + InLine[3].Y).InRange(0, this.Target.PixelHeight - 1) && ((Circle[y0 + (int)InLine[3].Y].Count & 1) != 0))
                Circle[y0 + (int)InLine[3].Y].Add(x0 + (int)InLine[3].X);

            if ((y0 + CP[0].Y).InRange(0, this.Target.PixelHeight - 1) && ((Circle[y0 + CP[0].Y].Count & 1) != 0))
                Circle[y0 + CP[0].Y].Add(x0 + CP[0].X);

            if ((y0 + CP[1].Y).InRange(0, this.Target.PixelHeight - 1) && ((Circle[y0 + CP[1].Y].Count & 1) != 0))
                Circle[y0 + CP[1].Y].Add(x0 + CP[1].X);
            #endregion

            #region ブレンド
            if (this.CompositingMode == CompositingMode.SourceOver)
            {
                for (int i = 0; i < Circle.Length; i++)
                {
                    Circle[i].Sort();

                    if (Circle[i].Count == 0)
                        continue;

                    for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                        this.Target.DrawXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, BARGB);
                }
            }
            #endregion

            #region コピー
            else
            {
                for (int i = 0; i < Circle.Length; i++)
                {
                    Circle[i].Sort();

                    if (Circle[i].Count == 0)
                        continue;

                    for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                        this.Target.CopyXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, ARGB);
                }
            }
            #endregion
        }

        /// <summary>塗りつぶしの扇形を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rect">扇形を描く長方形のパラメータを収めたRect</param>
        /// <param name="StartAngle">X軸から扇形の最初の辺まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから扇形の二番目の辺まで、時計回りに測定した角度(度単位)</param>
        public void FillPie(BaseBrush FillBrush, Rect Rect, double StartAngle, double EndAngle)
        {
            FillPie(FillBrush, Rect.Left, Rect.Top, Rect.Width, Rect.Height, StartAngle, EndAngle);
        }

        /// <summary>塗りつぶしの扇形を描く<para><see cref="System.NetFramework.BaseBrush"/> も参照してください。</para></summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">扇形を描く長方形の左上端座標X</param>
        /// <param name="Top">扇形を描く長方形の左上端座標Y</param>
        /// <param name="Width">扇形を描く長方形の幅</param>
        /// <param name="Height">扇形を描く長方形の高さ</param>
        /// <param name="StartAngle">X軸から扇形の最初の辺まで、時計回りに測定した角度(度単位)</param>
        /// <param name="EndAngle">StartAngleから扇形の二番目の辺まで、時計回りに測定した角度(度単位)</param>
        public void FillPie(BaseBrush FillBrush, double Left, double Top, double Width, double Height, double StartAngle, double EndAngle)
        {
            if (EndAngle == 0) return;

            if (Width <= 0) return;
            if (Height <= 0) return;

            if (Math.Abs(EndAngle) >= 360)
            {
                FillEllipse(FillBrush, Left, Top, Width, Height);
                return;
            }

            if (Left > this.Target.PixelWidth) return;
            if (Top > this.Target.PixelHeight) return;

            if (Left <= -Width) return;
            if (Top <= -Height) return;

            #region 座標を求める
            StartAngle = StartAngle.RotateClipping(0, 360);

            double degEnd = (StartAngle + EndAngle).RotateClipping(0, 360);

            if (EndAngle < 0) ExtraClass.Swap(ref StartAngle, ref degEnd);

            double SA = StartAngle * Math.PI / 180.0;
            double EA = degEnd * Math.PI / 180.0;

            Quadrants Quad, EndQuad, BaseQuad;

            //始点の象限を時計回りで定義する
            if (StartAngle == 360 || (0 <= StartAngle && StartAngle < 90))
                Quad = Quadrants.FirstQuadrant;

            else if (90 <= StartAngle && StartAngle < 180)
                Quad = Quadrants.SecondQuadrant;

            else if (180 <= StartAngle && StartAngle < 270)
                Quad = Quadrants.ThirdQuadrant;

            else
                Quad = Quadrants.FourthQuadrant;

            //終点の象限を時計回りで定義する
            if (0 < degEnd && degEnd <= 90)
                EndQuad = Quadrants.FirstQuadrant;

            else if (90 < degEnd && degEnd <= 180)
                EndQuad = Quadrants.SecondQuadrant;

            else if (180 < degEnd && degEnd <= 270)
                EndQuad = Quadrants.ThirdQuadrant;

            else
                EndQuad = Quadrants.FourthQuadrant;

            BaseQuad = Quad;

            double A = Width / 2.0;
            double B = Height / 2.0;
            int x0 = (int)(Left + A);
            int y0 = (int)(Top + B);

            Collections.Generic.List<int>[] Circle = new System.Collections.Generic.List<int>[this.Target.PixelHeight];

            for (int i = 0; i < Circle.Length; i++)
                Circle[i] = new System.Collections.Generic.List<int>();

            double tmp;

            double a = (Width <= Height ? 1.0 : ((tmp = B / A) * (tmp)));
            double b = (Height <= Width ? 1.0 : ((tmp = A / B) * (tmp)));
            int A2 = (a * 2.0).ToFix();
            int B2 = (b * 2.0).ToFix();
            int A4 = (a * 4.0).ToFix();
            int B4 = (b * 4.0).ToFix();

            iPoint SP = new iPoint((int)(A * Math.Cos(SA)), (int)(B * Math.Sin(SA)));
            iPoint EP = new iPoint((int)(A * Math.Cos(EA)), (int)(B * Math.Sin(EA)));
            int x = Math.Abs(SP.X);
            int y = Math.Abs(SP.Y);
            int ex = Math.Abs(EP.X);
            int ey = Math.Abs(EP.Y);
            bool Add;

            int F = -A2 * x + B4 * y + B2 + a.ToFix();

            bool EndFlag = (ey * b) < (ex * a);

            if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                Add = true;
            }

            else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
            {
                if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                Add = false;
            }

            else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                Add = true;
            }

            else
            {
                if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                Add = false;
            }

            //円枠のXを求める
            while (!(((Quad & EndQuad) != 0) && (EndFlag ? y == ey : x == ex)))
            {
                if (F >= 0 && ((Add && x == 0) || (!Add && y == 0)))
                {
                    if ((Quad & Quadrants.FourthQuadrant) == Quadrants.FourthQuadrant)
                        Quad = Quadrants.FirstQuadrant;

                    else
                        Quad = (Quadrants)((int)Quad << 1);

                    Add = !Add;

                    if (x == 0)
                    {
                        x++;
                        F -= A4 * x;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                            if ((y0 + 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + 1].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 - x);
                        }

                        else
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                            if ((y0 - 1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - 1].Add(x0 + x);
                        }

                        y++;
                    }
                }

                if (Add)
                {
                    if (F >= 0)
                    {
                        x--;
                        F -= A4 * x;
                    }

                    else
                    {
                        y++;
                        F += B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
                    }
                }

                else
                {
                    if (F < 0)
                    {
                        F += A4 * x;
                        x++;
                    }

                    else
                    {
                        F -= B4 * y + B2;

                        if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                        }

                        else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                        {
                            if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                        }

                        else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                        {
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                        }

                        else
                            if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);

                        y--;
                    }
                }
            }

            if (!Add)
            {
                if ((Quad & Quadrants.FirstQuadrant) == Quadrants.FirstQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 + x);
                }

                else if ((Quad & Quadrants.SecondQuadrant) == Quadrants.SecondQuadrant)
                {
                    if ((y0 + y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + y].Add(x0 - x);
                }

                else if ((Quad & Quadrants.ThirdQuadrant) == Quadrants.ThirdQuadrant)
                {
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 - x);
                }

                else
                    if ((y0 - y).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 - y].Add(x0 + x);
            }

            EP.X = (EP.X < 0 ? -x : x);
            EP.Y = (EP.Y < 0 ? -y : y);

            iPoint SP2 = new iPoint(0, 0);
            iPoint EP2 = new iPoint(0, 0);

            //ブツ切りの部分の斜線を求める
            if (SP.Y != SP2.Y)
            {
                int iX1 = SP.X;
                int iX2 = SP2.X;
                int iY1 = SP.Y;
                int iY2 = SP2.Y;

                int dstX, dstY;
                int addX = 1, addY = 1;
                int counter = 0;  //カウンタ

                dstX = iX2 - iX1;

                //始点から終点までの、x,yそれぞれの距離を求める
                if (dstX < 0)
                {
                    dstX = -dstX;
                    addX = -1;
                }

                dstY = iY2 - iY1;

                if (dstY < 0)
                {
                    dstY = -dstY;
                    addY = -1;
                }

                //距離を比較
                if (dstX > dstY)
                {
                    // X方向に点を打っていく
                    while (iX1 != iX2)
                    {
                        counter += dstY;
                        if (counter > dstX)
                        {
                            counter -= dstX;
                            iY1 += addY;

                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY1].Add(x0 + iX1);
                        }

                        iX1 += addX;
                    }
                }

                else
                {
                    counter += dstX;
                    iY1 += addY;

                    // Y方向に点を打っていく
                    while (iY1 != iY2)
                    {
                        if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                        counter += dstX;
                        if (counter > dstY)
                        {
                            counter -= dstY;
                            iX1 += addX;
                        }

                        iY1 += addY;
                    }
                }
            }

            if (EP.Y != EP2.Y)
            {
                int iX1 = EP.X;
                int iX2 = EP2.X;
                int iY1 = EP.Y;
                int iY2 = EP2.Y;

                int dstX, dstY;
                int addX = 1, addY = 1;
                int counter = 0;  //カウンタ

                dstX = iX2 - iX1;

                //始点から終点までの、x,yそれぞれの距離を求める
                if (dstX < 0)
                {
                    dstX = -dstX;
                    addX = -1;
                }

                dstY = iY2 - iY1;

                if (dstY < 0)
                {
                    dstY = -dstY;
                    addY = -1;
                }

                //距離を比較
                if (dstX > dstY)
                {
                    // X方向に点を打っていく
                    while (iX1 != iX2)
                    {
                        counter += dstY;
                        if (counter > dstX)
                        {
                            counter -= dstX;
                            iY1 += addY;

                            if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1) && (iY1 != iY2)) Circle[y0 + iY1].Add(x0 + iX1);
                        }

                        iX1 += addX;
                    }
                }

                else
                {
                    counter += dstX;
                    iY1 += addY;

                    // Y方向に点を打っていく
                    while (iY1 != iY2)
                    {
                        if ((y0 + iY1).InRange(0, this.Target.PixelHeight - 1)) Circle[y0 + iY1].Add(x0 + iX1);

                        counter += dstX;
                        if (counter > dstY)
                        {
                            counter -= dstY;
                            iX1 += addX;
                        }

                        iY1 += addY;
                    }
                }
            }

            if (y0.InRange(0, this.Target.PixelHeight - 1))
            {
                if ((Circle[y0].Count & 1) == 0)
                {
                    Circle[y0].Add(x0);
                    Circle[y0].Add(x0);
                }

                else
                    Circle[y0].Add(x0);
            }
            #endregion

            #region HatchBrushとImageBrush
            if (FillBrush.BrushType != BrushType.SolidColorBrush)
            {
                Func<int, int, int> func;

                if (FillBrush.BrushType == BrushType.HatchBrush)
                    func = (FillBrush.GetBrush() as HatchBrush).GetPatternPixel;

                else
                    func = FillBrush.GetPixelImage;

                #region ブレンド
                if (this.CompositingMode == CompositingMode.SourceOver)
                {
                    for (int i = 0; i < Circle.Length; i++)
                    {
                        Circle[i].Sort();

                        if (Circle[i].Count == 0)
                            continue;

                        for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                            this.Target.DrawXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, func);
                    }
                }
                #endregion

                #region コピー
                else
                {
                    for (int i = 0; i < Circle.Length; i++)
                    {
                        Circle[i].Sort();

                        if (Circle[i].Count == 0)
                            continue;

                        for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                            this.Target.CopyXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, func);
                    }
                }
                #endregion
            }
            #endregion

            #region SolidColorBrush
            else
            {
                int ARGB = FillBrush.GetPixelSolid();
                byte[] BARGB = ARGB.CalcAlphaBlend();

                #region ブレンド
                if (this.CompositingMode == CompositingMode.SourceOver)
                {
                    for (int i = 0; i < Circle.Length; i++)
                    {
                        Circle[i].Sort();

                        if (Circle[i].Count == 0)
                            continue;

                        for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                            this.Target.DrawXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, BARGB);
                    }
                }
                #endregion

                #region コピー
                else
                {
                    for (int i = 0; i < Circle.Length; i++)
                    {
                        Circle[i].Sort();

                        if (Circle[i].Count == 0)
                            continue;

                        for (int j = 0; j + 1 < Circle[i].Count; j += 2)
                            this.Target.CopyXLine(Circle[i][j].Clipping(0, this.Target.PixelWidth), Circle[i][j + 1].Clipping(0, this.Target.PixelWidth), i, ARGB);
                    }
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region 画像
        /// <summary>イメージを指定位置に原寸大で描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, double Left, double Top)
        {
            if (Left >= this.Target.PixelWidth) return;
            if (Left <= -this.Target.PixelWidth) return;        
            if (Top >= this.Target.PixelHeight) return;
            if (Top <= -this.Target.PixelHeight) return;

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(Left, Top, DrawImage, RasterOperation.SrcAlpha);

            else
                this.Target.BitBltCopy(Left, Top, DrawImage, RasterOperation.SrcAlpha);
        }

        /// <summary>イメージを指定位置に原寸大で描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Opacity">イメージ全体に対して不透明度を0.0～1.0の範囲で設定する</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, double Left, double Top, double Opacity)
        {
            if (Opacity <= 0.0)
                return;

            if (Opacity >= 1.0)
                this.DrawImage(DrawImage, Left, Top);

            if (Left >= this.Target.PixelWidth) return;
            if (Left <= -this.Target.PixelWidth) return;
            if (Top >= this.Target.PixelHeight) return;
            if (Top <= -this.Target.PixelHeight) return;

            byte Alpha = (byte)(0xFF * Opacity);

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(Left, Top, DrawImage, RasterOperation.SrcAlpha, Alpha);

            else
                this.Target.BitBltCopy(Left, Top, DrawImage, RasterOperation.SrcAlpha, Alpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Width">イメージの幅</param>
        /// <param name="Height">イメージの高さ</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, double Left, double Top, double Width, double Height)
        {
            Rect RectParameter = new Rect(Left, Top, Width, Height);

            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, DrawImage, RasterOperation.SrcAlpha);

            else
                this.Target.BitBltCopy(RectParameter, DrawImage, RasterOperation.SrcAlpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter)
        {
            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, DrawImage, RasterOperation.SrcAlpha);

            else
                this.Target.BitBltCopy(RectParameter, DrawImage, RasterOperation.SrcAlpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="Opacity">イメージ全体に対して不透明度を0.0～1.0の範囲で設定する</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter, double Opacity)
        {
            if (Opacity <= 0.0)
                return;

            if (Opacity >= 1.0)
                this.DrawImage(DrawImage, RectParameter);

            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            byte Alpha = (byte)(0xFF * Opacity);

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, DrawImage, RasterOperation.SrcAlpha, Alpha);

            else
                this.Target.BitBltCopy(RectParameter, DrawImage, RasterOperation.SrcAlpha, Alpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="SrcParamaeter">イメージの描画する範囲</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter, iRect SrcParamaeter)
        {
            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (SrcParamaeter.X < 0) SrcParamaeter.X = 0;
            if (SrcParamaeter.Y < 0) SrcParamaeter.Y = 0;
            if (SrcParamaeter.Width > DrawImage.PixelWidth) SrcParamaeter.Width = DrawImage.PixelWidth;
            if (SrcParamaeter.Height > DrawImage.PixelHeight) SrcParamaeter.Height = DrawImage.PixelHeight;

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOperation.SrcAlpha);

            else
                this.Target.BitBltCopy(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOperation.SrcAlpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="SrcParamaeter">イメージの描画する範囲</param>
        /// <param name="Opacity">イメージ全体に対して不透明度を0.0～1.0の範囲で設定する</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter, iRect SrcParamaeter, double Opacity)
        {
            if (Opacity <= 0.0)
                return;

            if (Opacity >= 1.0)
                this.DrawImage(DrawImage, RectParameter, SrcParamaeter);

            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (SrcParamaeter.X < 0) SrcParamaeter.X = 0;
            if (SrcParamaeter.Y < 0) SrcParamaeter.Y = 0;
            if (SrcParamaeter.Width > DrawImage.PixelWidth) SrcParamaeter.Width = DrawImage.PixelWidth;
            if (SrcParamaeter.Height > DrawImage.PixelHeight) SrcParamaeter.Height = DrawImage.PixelHeight;

            byte Alpha = (byte)(0xFF * Opacity);

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOperation.SrcAlpha, Alpha);

            else
                this.Target.BitBltCopy(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOperation.SrcAlpha, Alpha);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="SrcParamaeter">イメージの描画する範囲</param>
        /// <param name="RasterOP">ラスターオペレーション</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter, iRect SrcParamaeter, RasterOperation RasterOP)
        {
            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (SrcParamaeter.X < 0) SrcParamaeter.X = 0;
            if (SrcParamaeter.Y < 0) SrcParamaeter.Y = 0;
            if (SrcParamaeter.Width > DrawImage.PixelWidth) SrcParamaeter.Width = DrawImage.PixelWidth;
            if (SrcParamaeter.Height > DrawImage.PixelHeight) SrcParamaeter.Height = DrawImage.PixelHeight;

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOP);

            else
                this.Target.BitBltCopy(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOP);
        }

        /// <summary>イメージオブジェクトを指定位置に指定サイズで描く<para><see cref="System.NetFramework.CustomWriteableBitmap"/> も参照してください。</para></summary>
        /// <param name="DrawImage">描きたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="SrcParamaeter">イメージの描画する範囲</param>
        /// <param name="RasterOP">ラスターオペレーション</param>
        /// <param name="Opacity">イメージ全体に対して不透明度を0.0～1.0の範囲で設定する(この範囲を超えた場合は1.0に下回った場合は0に補正される)</param>
        public void DrawImage(CustomWriteableBitmap DrawImage, Rect RectParameter, iRect SrcParamaeter, RasterOperation RasterOP, double Opacity)
        {
            if (Opacity <= 0.0)
                return;

            if (Opacity >= 1.0)
                this.DrawImage(DrawImage, RectParameter, SrcParamaeter, RasterOP);

            if (RectParameter.X < 0) RectParameter.X = 0;
            if (RectParameter.Y < 0) RectParameter.Y = 0;
            if (RectParameter.Width > this.Target.PixelWidth) RectParameter.Width = this.Target.PixelWidth;
            if (RectParameter.Height > this.Target.PixelHeight) RectParameter.Height = this.Target.PixelHeight;

            if (SrcParamaeter.X < 0) SrcParamaeter.X = 0;
            if (SrcParamaeter.Y < 0) SrcParamaeter.Y = 0;
            if (SrcParamaeter.Width > DrawImage.PixelWidth) SrcParamaeter.Width = DrawImage.PixelWidth;
            if (SrcParamaeter.Height > DrawImage.PixelHeight) SrcParamaeter.Height = DrawImage.PixelHeight;

            byte Alpha = (byte)(0xFF * Opacity);

            if (this.CompositingMode == CompositingMode.SourceOver)
                this.Target.BitBltBlend(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOP, Alpha);

            else
                this.Target.BitBltCopy(RectParameter, SrcParamaeter, DrawImage, this.SmoothingMode, RasterOP, Alpha);
        }
        #endregion
    }
    #endregion

    #region VectorGraphicsクラス
    /// <summary>SilverlightのShapeコントロールなどを配置・削除するクラス</summary>
    /// <remarks>
    /// <example><para>VectorGraphics g = new VectorGraphics(cvs); //cvsはCanvas</para>
    /// <para>VectorGraphics g = Graphics.FromCanvas(cvs);</para>
    /// <para>g.GetObject(2); //実際にメソッドを使用</para></example></remarks>
    public class VectorGraphics : Graphics
    {
        #region フィールドとプロパティ、その他のメソッド
        private int OBCnt;
        private Canvas Target;
        /// <summary>オブジェクトを生成するクラス</summary>
        private CreateVector CV;
        /// <summary>オブジェクトの編集するクラス</summary>
        private EditVector EVK, EVA;
        /// <summary>オブジェクトのタイプを入れておくリスト</summary>
        private Collections.Generic.List<ObjectType> ObjectTypeCollection;

        /// <summary>Typeから列挙体ObjectTypeを取得する</summary>
        /// <param name="Type">判別したいType</param>
        /// <returns>Typeから判別したObjectType</returns>
        private ObjectType GetObjectType(Type Type)
        {
            ObjectType res;

            if (Type.Equals(typeof(Line)))
                res = ObjectType.Line;

            else if (Type.Equals(typeof(Rectangle)))
                res = ObjectType.Rectangle;

            else if (Type.Equals(typeof(Ellipse)))
                res = ObjectType.Ellipse;

            else if (Type.Equals(typeof(Polygon)))
                res = ObjectType.Polygon;

            else if (Type.Equals(typeof(Polyline)))
                res = ObjectType.Polyline;

            else if (Type.Equals(typeof(Path)))
                res = ObjectType.Path;

            else if (Type.Equals(typeof(Image)))
                res = ObjectType.Image;

            else if (Type.Equals(typeof(TextBlock)))
                res = ObjectType.String;

            else
                res = ObjectType.Rest;

            return res;
        }

        /// <summary>このインスタンス内でセットしたオブジェクトの総数</summary>
        public int ObjectCount
        {
            get { return this.OBCnt; }
            private set { this.OBCnt = value; }
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内である種類のオブジェクト全てとそのインデックスを取得する</summary>
        /// <param name="Type">取得したオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <returns>取得したオブジェクトとインデックスの値を持った配列(FirstValue:オブジェクト、SecondValue:インデックス)</returns>
        /// <remarks>このプロパティの使用例
        /// <example><code><para>NeverWherePluralsValue&lt;UIElement, int&gt;[] tmp = VG[ObjectType.Line]; //VGはVectorGraphics</para>
        /// <para>tmp[0].FirstValue.Opacity = 0.5; //VGインスタンス内でセットしたオブジェクトの内Line型一番初めのオブジェクトの不透明度を0.5にする</para>
        /// <para>複数の型へのアクセス</para>
        /// <para>NeverWherePluralsValue&lt;UIElement, int&gt;[] tmp = VG[ObjectType.Line | ObjectType.Rectangle];</para>
        /// <para>VG.MoveObject(tmp[1].SecondValue, 20, 30); //VGインスタンス内でセットしたオブジェクトの内Line型とRectangle型の二番目のオブジェクトを(20, 30)の位置に移動する</para></code></example></remarks>
        public NeverWherePluralsValue<UIElement, int>[] this[ObjectType Type]
        {
            get { return GetObjects(Type).ToArray(); }
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを取得、または指定する位置にオブジェクトを挿入する(このCanvas上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Index">取得、挿入したいオブジェクトのインデックス</param>
        /// <returns>取得したオブジェクト</returns>
        public UIElement this[int Index]
        {
            get { return this.Target.Children[this.Target.Children.Count - this.ObjectCount + Index]; }
            set
            {
                this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index, value);
                this.ObjectTypeCollection.Insert(Index, GetObjectType(value.GetType()));
                this.ObjectCount++;
            }
        }

        /// <summary>オブジェクトの作成をするクラスを取得する</summary>
        /// <remarks>このプロパティの使用例
        /// <example><code><para>Line line = VG.Create.Line(Pens.Blue,20,20,100,100); //VGはVectorGraphics</para></code></example></remarks>
        public CreateVector Create
        {
            get { return this.CV; }
        }

        /// <summary>オブジェクトの編集をするクラスを取得する(インデックスは全オブジェクト内でのインデックス)</summary>
        /// <remarks>注意
        /// <para>このプロパティではLine編集の時にRectangleを対象にしたりするとエラーになります。</para>
        /// <para>このプロパティの使用例</para>
        /// <example><code><para>VG.EditAll.Line(0,Pens.Blue,20,20,100,100); //VGはVectorGraphics、1番始めのインデックスのオブジェクト(Lineの時のみ)を編集する</para></code></example></remarks>
        public EditVector EditAll
        {
            get { return this.EVA; }
        }

        /// <summary>オブジェクトの編集をするクラスを取得する(インデックスは種類別インデックス)</summary>
        /// <remarks>注意
        /// <para>このプロパティは配列内から種類別で集めてからアクセスするのでやや速度は劣ります。</para>
        /// <para>このプロパティの使用例</para>
        /// <example><code><para>VG.EditKind.Line(0,Pens.Blue,20,20,100,100); //VGはVectorGraphics、Lineオブジェクトの中で一番初めのオブジェクトを編集する</para></code></example></remarks>
        public EditVector EditKind
        {
            get { return this.EVK; }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">対象のCanvas</param>
        public VectorGraphics(Canvas Target)
        {
            this.Target = Target;
            this.ObjectCount = 0;
            this.ObjectTypeCollection = new Collections.Generic.List<ObjectType>();

            //編集対象(全て)を取得するメソッド
            Func<int, ObjectType, UIElement> funcA = (int Index, ObjectType Tag) =>
            {
                return this[Index];
            };

            //編集対象(種類別)を取得するメソッド
            Func<int, ObjectType, UIElement> funcK = (int Index, ObjectType Tag) =>
            {
                return GetObjectElement(Tag, Index);
            };

            this.CV = new CreateVector();
            this.EVA = new EditVector(funcA);
            this.EVK = new EditVector(funcK);
        }

        /// <summary>指定したインデックス(このインスタンス内での)のオブジェクトを削除する</summary>
        /// <param name="Index">削除したいオブジェクトのインデックス</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        private void RemoveObject(int Index)
        {
            if (0 > Index || Index >= this.ObjectCount)
                throw new ArgumentOutOfRangeException("Index", "削除したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            this.Target.Children.RemoveAt(this.Target.Children.Count - this.ObjectCount + Index);
            this.ObjectTypeCollection.RemoveAt(Index);
            this.ObjectCount--;
        }

        /// <summary>指定した文字列を指定したフォントで描画した場合のサイズを返す。</summary>
        /// <param name="Text">描画する文字列</param>
        /// <param name="Font">描画時のフォント</param>
        /// <returns>描画した場合の文字列のサイズ</returns>
        public Size MeasureString(String Text, Font Font)
        {
            TextBlock TB = this.CV.String(Text, Font, Pens.Black, new Point(0, 0));
            SetObject(TB);
            Size S = new Size(TB.ActualWidth, TB.ActualHeight);
            BackRemove();
            return S;
        }
        #endregion

        #region オブジェクト操作メソッド
        /// <summary>このインスタンス内でセットしたオブジェクトを取得する</summary>
        /// <param name="Index">取得したいオブジェクトのインデックス</param>
        /// <returns>取得したオブジェクト</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        public UIElement GetObject(int Index)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "取得したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            return this.Target.Children[this.Target.Children.Count - this.ObjectCount + Index];
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを型を指定してオブジェクトとインデックスを取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <param name="Index">取得したいオブジェクトの種類別インデックス</param>
        /// <returns>取得したオブジェクトとインデックスの複合構造体(FirstValue:オブジェクト、SecondValue:インデックス) 存在しない場合はnull,-1</returns>
        public NeverWherePluralsValue<UIElement, int> GetObject(ObjectType Type, int Index)
        {
            int cnt = 0;
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                {
                    if (cnt == Index)
                        return new NeverWherePluralsValue<UIElement, int>(this.Target.Children[this.Target.Children.Count - this.ObjectCount + i], i);

                    cnt++;
                }
            }

            return new NeverWherePluralsValue<UIElement, int>(null, -1);
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを型を指定して取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <param name="Index">取得したいオブジェクトの種類別インデックス</param>
        /// <returns>取得したオブジェクト 存在しない場合はnull</returns>
        public UIElement GetObjectElement(ObjectType Type, int Index)
        {
            int cnt = 0;
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                {
                    if (cnt == Index)
                        return this.Target.Children[this.Target.Children.Count - this.ObjectCount + i];

                    cnt++;
                }
            }

            return null;
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを型を指定してそのインデックス取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <param name="Index">取得したいオブジェクトの種類別インデックス</param>
        /// <returns>取得したインデックス 存在しない場合は-1</returns>
        public int GetObjectIndex(ObjectType Type, int Index)
        {
            int cnt = 0;
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                {
                    if (cnt == Index)
                        return i;

                    cnt++;
                }
            }

            return -1;
        }

        /// <summary>このインスタンス内でセットした複数のオブジェクトを取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <returns>取得した反復クラス</returns>
        public System.Collections.Generic.IEnumerable<UIElement> GetObjectsElement(ObjectType Type)
        {
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                    yield return this.Target.Children[this.Target.Children.Count - this.ObjectCount + i];
            }
        }

        /// <summary>このインスタンス内でセットした複数のオブジェクトとのインデックスのみを取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <returns>取得した反復クラス</returns>
        public System.Collections.Generic.IEnumerable<int> GetObjectsIndex(ObjectType Type)
        {
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                    yield return i;
            }
        }

        /// <summary>このインスタンス内でセットした複数のオブジェクトとそのインデックスを取得する</summary>
        /// <param name="Type">取得したいオブジェクトの種類(複数をOR処理して渡しても良い)</param>
        /// <returns>取得した反復クラス(FirstValue:オブジェクト、SecondValue:インデックス)</returns>
        /// <remarks>このメソッドの使用例(ただしこの例では速度が遅いのであらかじめ配列を取得しておく必要がある)
        /// <example><code><para>NeverWherePluralsValue&lt;UIElement, int&gt;[] tmp = VG.GetObjects(ObjectType.Line).ToArray(); //VGはVectorGraphics</para>
        /// <para>tmp[0].FirstValue.Opacity = 0.5; //VGインスタンス内でセットしたオブジェクトの内Line型一番初めのオブジェクトの不透明度を0.5にする</para>
        /// <para>複数の型へのアクセス</para>
        /// <para>NeverWherePluralsValue&lt;UIElement, int&gt;[] tmp = VG.GetObjects(ObjectType.Line | ObjectType.Rectangle).ToArray();</para>
        /// <para>VG.MoveObject(tmp[1].SecondValue, 20, 30); //VGインスタンス内でセットしたオブジェクトの内Line型とRectangle型の二番目のオブジェクトを(20, 30)の位置に移動する</para></code></example></remarks>
        public System.Collections.Generic.IEnumerable<NeverWherePluralsValue<UIElement, int>> GetObjects(ObjectType Type)
        {
            for (int i = 0; i < this.ObjectCount; i++)
            {
                if ((this.ObjectTypeCollection[i] & Type) != ObjectType.None)
                    yield return new NeverWherePluralsValue<UIElement, int>(this.Target.Children[this.Target.Children.Count - this.ObjectCount + i], i);
            }
        }

        /// <summary>オブジェクトを既定位置セットする(このCanvas上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Obj">セットしたい図形</param>
        public void SetObject(UIElement Obj)
        {
            this.Target.Children.Add(Obj);
            this.ObjectTypeCollection.Add(GetObjectType(Obj.GetType()));
            this.ObjectCount++;
        }

        /// <summary>オブジェクトを指定位置にセットする(このCanvas上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Obj">セットしたい図形</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        public void SetObject(UIElement Obj, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);
            this.Target.Children.Add(Obj);
            this.ObjectTypeCollection.Add(GetObjectType(Obj.GetType()));
            this.ObjectCount++;
        }

        /// <summary>オブジェクトをインデックス指定して既定位置セットする(このCanvas上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Index">挿入するインデックス位置</param>
        /// <param name="Obj">セットしたい図形</param>
        public void SetObject(int Index, UIElement Obj)
        {
            this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index, Obj);
            this.ObjectTypeCollection.Insert(Index, GetObjectType(Obj.GetType()));
            this.ObjectCount++;
        }

        /// <summary>オブジェクトをインデックス指定して指定位置にセットする(このCanvas上に既に設置されているオブジェクトは無効)</summary>
        /// <param name="Index">挿入するインデックス位置</param>
        /// <param name="Obj">セットしたい図形</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        public void SetObject(int Index, UIElement Obj, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);
            this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index, Obj);
            this.ObjectTypeCollection.Insert(Index, GetObjectType(Obj.GetType()));
            this.ObjectCount++;
        }

        /// <summary>指定した2つのインデックス位置のオブジェクトを交換する</summary>
        /// <param name="Index1">1つ目のオブジェクトのインデックス</param>
        /// <param name="Index2">2つ目のオブジェクトのインデックス</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Index1かIndex2が期待する範囲内に収まっていなかった場合に発生</exception>
        public void SwapObject(int Index1, int Index2)
        {
            if (!Index1.InRange(0, this.ObjectCount - 1, Index2))
                throw new ArgumentOutOfRangeException("Index1 , Index2", "交換したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            if (Index2 < Index1) ExtraClass.Swap(ref Index1, ref Index2);

            UIElement tmp1 = this.Target.Children[this.Target.Children.Count - this.ObjectCount + Index1];
            UIElement tmp2 = this.Target.Children[this.Target.Children.Count - this.ObjectCount + Index2];
            this.Target.Children.RemoveAt(this.Target.Children.Count - this.ObjectCount + Index1);
            this.Target.Children.RemoveAt(this.Target.Children.Count - this.ObjectCount + Index2);
            this.ObjectTypeCollection.RemoveAt(Index1);
            this.ObjectTypeCollection.RemoveAt(Index2 - 1);

            this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index1 + 2, tmp2);
            this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index2 + 1, tmp1);
            this.ObjectTypeCollection.Insert(Index1, GetObjectType(tmp2.GetType()));
            this.ObjectTypeCollection.Insert(Index2, GetObjectType(tmp1.GetType()));
        }

        /// <summary>指定したインデックス位置のオブジェクトに他のオブジェクトを代入する</summary>
        /// <param name="Index">オブジェクトのインデックス</param>
        /// <param name="Obj">代入するオブジェクト</param>
        /// <returns>代入する前にインデックス位置にあったオブジェクト</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        public UIElement SwapObject(int Index, UIElement Obj)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "交換したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            UIElement tmp = this.Target.Children[this.Target.Children.Count - this.ObjectCount + Index];
            this.Target.Children.RemoveAt(this.Target.Children.Count - this.ObjectCount + Index);
            this.Target.Children.Insert(this.Target.Children.Count - this.ObjectCount + Index + 1, Obj);
            
            this.ObjectTypeCollection.RemoveAt(Index);
            this.ObjectTypeCollection.Insert(Index, GetObjectType(Obj.GetType()));

            return tmp;
        }

        /// <summary>このインスタンス内でセットしたオブジェクトを全て破棄する</summary>
        public void Clear()
        {
            for (int i = 0; i < this.ObjectCount; i++)
                this.Target.Children.RemoveAt(this.Target.Children.Count - 1);

            this.ObjectTypeCollection.Clear();
            this.ObjectCount = 0;
        }

        /// <summary>一つ前にセットしたオブジェクトを破棄する</summary>
        public void BackRemove()
        {
            if (this.ObjectCount == 0) return;
            RemoveObject(this.ObjectCount - 1);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトを破棄する</summary>
        /// <param name="Index">破棄したいオブジェクトのインデックス</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        public void Remove(int Index)
        {
            RemoveObject(Index);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトを移動する</summary>
        /// <param name="Index">移動したいオブジェクトのインデックス</param>
        /// <param name="Left">オブジェクトの左上端座標X</param>
        /// <param name="Top">オブジェクトの左上端座標Y</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        public void MoveObject(int Index, double Left, double Top)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "移動したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            this[Index].SetValue(Canvas.LeftProperty, Left);
            this[Index].SetValue(Canvas.TopProperty, Top);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトを相対的に移動する</summary>
        /// <param name="Index">移動したいオブジェクトのインデックス</param>
        /// <param name="X">動かしたい距離X</param>
        /// <param name="Y">動かしたい距離Y</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        public void RelativeMoveObject(int Index, double X, double Y)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "移動したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            this[Index].SetValue(Canvas.LeftProperty, (double)this[Index].GetValue(Canvas.LeftProperty) + X);
            this[Index].SetValue(Canvas.TopProperty, (double)this[Index].GetValue(Canvas.TopProperty) + Y);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトのサイズを変更する</summary>
        /// <param name="Index">サイズ変更したいオブジェクトのインデックス</param>
        /// <param name="Width">オブジェクトの幅</param>
        /// <param name="Height">オブジェクトの高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        /// <exception cref="System.ArgumentException">Width及びHeightがマイナスの場合に発生</exception>
        /// <remarks>注意
        /// <para>直線など幅指定ではなく始点終点などのパラメータで指定するオブジェクトを対象にすると期待する結果にならない事があります。</para></remarks>
        public void ResizeObject(int Index, double Width, double Height)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "移動したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            this[Index].SetValue(FrameworkElement.WidthProperty, Width);
            this[Index].SetValue(FrameworkElement.HeightProperty, Height);
        }

        /// <summary>このインスタンス内でセットしたオブジェクト内で指定したオブジェクトのサイズを相対的に変更する</summary>
        /// <param name="Index">サイズ変更したいオブジェクトのインデックス</param>
        /// <param name="X">オブジェクトの幅の相対差</param>
        /// <param name="Y">オブジェクトの高さの相対差</param>
        /// <exception cref="System.ArgumentOutOfRangeException">Indexが期待する範囲内に収まっていなかった場合に発生</exception>
        /// <exception cref="System.ArgumentException">幅及び高さがマイナスになった場合に発生</exception>
        /// <remarks>注意
        /// <para>直線など幅指定ではなく始点終点などのパラメータで指定するオブジェクトを対象にすると期待する結果にならない事があります。</para></remarks>
        public void RelativeResizeObject(int Index, double X, double Y)
        {
            if (!Index.InRange(0, this.ObjectCount - 1))
                throw new ArgumentOutOfRangeException("Index", "移動したいオブジェクトのインデックスが0未満かオブジェクトのセット数を超えています。");

            this[Index].SetValue(FrameworkElement.WidthProperty, (double)this[Index].GetValue(FrameworkElement.WidthProperty) + X);
            this[Index].SetValue(FrameworkElement.HeightProperty, (double)this[Index].GetValue(FrameworkElement.HeightProperty) + Y);
        }
        #endregion

        #region セットメソッド

        #region 図形セットメソッド

        #region 線オブジェクト
        /// <summary>直線オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        public void SetLine(Pen DrawPen, double X1, double Y1, double X2, double Y2)
        {
            Line line = this.CV.Line(DrawPen, X1, Y1, X2, Y2);

            SetObject(line);
        }

        /// <summary>直線オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        public void SetLine(Pen DrawPen, Point Point1, Point Point2)
        {
            Line line = this.CV.Line(DrawPen, Point1, Point2);

            SetObject(line);
        }

        /// <summary>接続された一連の直線オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public void SetLines(Pen DrawPen, Point[] Points)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polyline line = this.CV.Lines(DrawPen, tmp);

            SetObject(line);
        }

        /// <summary>接続された一連の直線オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public void SetLines(Pen DrawPen, PointCollection Points)
        {
            Polyline line = this.CV.Lines(DrawPen, Points);

            SetObject(line);
        }

        /// <summary>3次ベジエ曲線をセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        public void SetBezier(Pen DrawPen, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            Path path = this.CV.Bezier(DrawPen, Point1, Point2, Point3, Point4);

            SetObject(path);
        }

        /// <summary>連続3次ベジエ曲線をセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        public void SetBeziers(Pen DrawPen, Point[] Points)
        {
            Path path = this.CV.Beziers(DrawPen, Points);

            SetObject(path);
        }
        #endregion

        #region 平面オブジェクト
        /// <summary>長方形オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public void SetRectangle(Pen DrawPen, double Left, double Top, double Width, double Height)
        {
            Rectangle rect = this.CV.Rectangle(DrawPen, Left, Top, Width, Height);

            SetObject(rect);
        }

        /// <summary>長方形オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        public void SetRectangle(Pen DrawPen, Rect RectParameter)
        {
            Rectangle rect = this.CV.Rectangle(DrawPen, RectParameter);

            SetObject(rect);
        }

        /// <summary>塗りつぶしの長方形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public void SetFillRectangle(Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Rectangle rect = this.CV.FillRectangle(FillBrush, Left, Top, Width, Height);

            SetObject(rect);
        }

        /// <summary>塗りつぶしの長方形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        public void SetFillRectangle(Brush FillBrush, Rect RectParameter)
        {
            Rectangle rect = this.CV.FillRectangle(FillBrush, RectParameter);

            SetObject(rect);
        }

        /// <summary>楕円オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public void SetEllipse(Pen DrawPen, double Left, double Top, double Width, double Height)
        {
            Ellipse e = this.CV.Ellipse(DrawPen, Left, Top, Width, Height);

            SetObject(e);
        }

        /// <summary>楕円オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        public void SetEllipse(Pen DrawPen, Rect RectParameter)
        {
            Ellipse e = this.CV.Ellipse(DrawPen, RectParameter);

            SetObject(e);
        }

        /// <summary>塗りつぶしの楕円オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public void SetFillEllipse(Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Ellipse e = this.CV.FillEllipse(FillBrush, Left, Top, Width, Height);

            SetObject(e);
        }

        /// <summary>塗りつぶしの楕円オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        public void SetFillEllipse(Brush FillBrush, Rect RectParameter)
        {
            Ellipse e = this.CV.FillEllipse(FillBrush, RectParameter);

            SetObject(e);
        }

        /// <summary>多角形オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public void SetPolygon(Pen DrawPen, Point[] Points)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polygon p = this.CV.Polygon(DrawPen, tmp);

            SetObject(p);
        }

        /// <summary>多角形オブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public void SetPolygon(Pen DrawPen, PointCollection Points)
        {
            Polygon p = this.CV.Polygon(DrawPen, Points);

            SetObject(p);
        }

        /// <summary>塗りつぶしの多角形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public void SetFillPolygon(Brush FillBrush, Point[] Points)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polygon p = this.CV.FillPolygon(FillBrush, tmp);

            SetObject(p);
        }

        /// <summary>塗りつぶしの多角形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public void SetFillPolygon(Brush FillBrush, PointCollection Points)
        {
            Polygon p = this.CV.FillPolygon(FillBrush, Points);

            SetObject(p);
        }

        /// <summary>塗りつぶしの多角形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public void SetFillPolygon(Brush FillBrush, Point[] Points, FillRule Rule)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polygon p = this.CV.FillPolygon(FillBrush, tmp, Rule);

            SetObject(p);
        }

        /// <summary>塗りつぶしの多角形オブジェクトをセットする</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public void SetFillPolygon(Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polygon p = this.CV.FillPolygon(FillBrush, Points, Rule);

            SetObject(p);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public void SetPolyline(Pen DrawPen, Brush FillBrush, Point[] Points)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polyline line = this.CV.Polyline(DrawPen, FillBrush, tmp);

            SetObject(line);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public void SetPolyline(Pen DrawPen, Brush FillBrush, PointCollection Points)
        {
            Polyline line = this.CV.Polyline(DrawPen, FillBrush, Points);

            SetObject(line);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public void SetPolyline(Pen DrawPen, Brush FillBrush, Point[] Points, FillRule Rule)
        {
            PointCollection tmp = new PointCollection();
            foreach (Point P in Points)
                tmp.Add(P);

            Polyline line = this.CV.Polyline(DrawPen, FillBrush, tmp, Rule);

            SetObject(line);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトをセットする</summary>
        /// <param name="DrawPen">オブジェクトを描くPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public void SetPolyline(Pen DrawPen, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polyline line = this.CV.Polyline(DrawPen, FillBrush, Points, Rule);

            SetObject(line);
        }
        #endregion

        #endregion

        #region その他のセットメソッド
        /// <summary>文字列オブジェクトをセットする</summary>
        /// <param name="DrawString">セットしたい文字列</param>
        /// <param name="DrawFont">使用するフォント</param>
        /// <param name="DrawBrush">文字を書くブラシ</param>
        /// <param name="Left">文字列の左上端座標X</param>
        /// <param name="Top">文字列の左上端座標Y</param>
        public void SetString(String DrawString, Font DrawFont, Brush DrawBrush, double Left, double Top)
        {
            TextBlock TB = this.CV.String(DrawString, DrawFont, DrawBrush, Left, Top);

            SetObject(TB);
        }

        /// <summary>文字列オブジェクトをセットする</summary>
        /// <param name="DrawString">セットしたい文字列</param>
        /// <param name="DrawFont">使用するフォント</param>
        /// <param name="DrawBrush">文字を書くブラシ</param>
        /// <param name="Point">文字列オブジェクトの左上端の座標</param>
        public void SetString(String DrawString, Font DrawFont, Brush DrawBrush, Point Point)
        {
            TextBlock TB = this.CV.String(DrawString, DrawFont, DrawBrush, Point);

            SetObject(TB);
        }

        /// <summary>文字列オブジェクトをセットする</summary>
        /// <param name="DrawString">セットしたい文字列</param>
        /// <param name="DrawFont">使用するフォント</param>
        /// <param name="DrawBrush">文字を書くブラシ</param>
        /// <param name="Point">文字列オブジェクトの左上端の座標</param>
        /// <param name="TransformParameter">文字列オブジェクトの変換情報</param>
        public void SetString(String DrawString, Font DrawFont, Brush DrawBrush, Point Point, Transform TransformParameter)
        {
            TextBlock TB = this.CV.String(DrawString, DrawFont, DrawBrush, Point, TransformParameter);

            SetObject(TB);
        }

        /// <summary>イメージオブジェクトをセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        public void SetImage(ImageSource DrawImage, double Left, double Top)
        {
            Image img = this.CV.Image(DrawImage, Left, Top);

            SetObject(img);
        }

        /// <summary>イメージオブジェクトを指定サイズでセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Width">イメージの幅</param>
        /// <param name="Height">イメージの高さ</param>
        public void SetImage(ImageSource DrawImage, double Left, double Top, double Width, double Height)
        {
            Image img = this.CV.Image(DrawImage, Left, Top, Width, Height);

            SetObject(img);
        }

        /// <summary>イメージオブジェクトを指定サイズでセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        public void SetImage(ImageSource DrawImage, Rect RectParameter)
        {
            Image img = this.CV.Image(DrawImage, RectParameter);

            SetObject(img);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度でセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        public void SetImage(ImageSource DrawImage, Rect RectParameter, double Opacity)
        {
            Image img = this.CV.Image(DrawImage, RectParameter, Opacity);

            SetObject(img);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した変換に準じてセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        public void SetImage(ImageSource DrawImage, Rect RectParameter, Transform TransformParameter)
        {
            Image img = this.CV.Image(DrawImage, RectParameter, TransformParameter);

            SetObject(img);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した変換に準じてセットする</summary>
        /// <param name="DrawImage">セットしたいイメージ</param>
        /// <param name="RectParameter">イメージを描画するときの原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        public void SetImage(ImageSource DrawImage, Rect RectParameter, Transform TransformParameter, double Opacity)
        {
            Image img = this.CV.Image(DrawImage, RectParameter, TransformParameter, Opacity);

            SetObject(img);
        }
        #endregion

        #endregion
    }
    #endregion

    #region Graphics系クラスのサポートクラス

    #region RasterGraphicsのサポートクラス・構造体

    #region iPoint構造体
    /// <summary>int型のPoint</summary>
    public struct iPoint : IComparable<iPoint>, IEquatable<iPoint>
    {
        private int iX, iY;

        /// <summary>X座標</summary>
        public int X { get { return this.iX; } set { this.iX = value; } }

        /// <summary>Y座標</summary>
        public int Y { get { return this.iY; } set { this.iY = value; } }

        /// <summary>コンストラクタ</summary>
        /// <param name="X">座標X</param>
        /// <param name="Y">座標Y</param>
        public iPoint(int X, int Y)
        {
            this.iX = X;
            this.iY = Y;
        }

        /// <summary>iPointのこのインスタンスのハッシュ コードを取得する</summary>
        /// <returns>iPointのインスタンスのハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.iX ^ this.iY;
        }

        /// <summary>現在のインスタンスを表す文字列を返す</summary>
        /// <returns>現在のインスタンスを表す文字列</returns>
        public override string ToString()
        {
            return string.Format("{0},{1}", this.X, this.Y);
        }

        /// <summary>値がiPointのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iPointの現在のインスタンスと比較するiPoint</param>
        /// <returns>iPointのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is iPoint))
                return false;

            iPoint tmp = (iPoint)obj;

            return this.iX == tmp.iX && this.iY == tmp.iY;
        }

        /// <summary>値がiPointのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iPointの現在のインスタンスと比較するiPoint</param>
        /// <returns>iPointのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public bool Equals(iPoint obj)
        {
            return this.iX == obj.iX && this.iY == obj.iY;
        }

        /// <summary>指定されたiPointと比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="value">比較するiPoint</param>
        /// <returns>valueと比較して値が大きければ0より大きい値、小さければ0より小さい値、等しければ0を返す</returns>
        public int CompareTo(iPoint value)
        {
            return (this.iY - value.iY) + (this.iX - value.iX);
        }

        /// <summary>2つのiPoint等しくないかどうかを返す</summary>
        /// <param name="A">1つ目のiPoint</param>
        /// <param name="B">2つ目のiPoint</param>
        /// <returns>等しくなかったらtrue、等しかったらfalseを返す</returns>
        public static bool operator !=(iPoint A, iPoint B)
        {
            return A.iX != B.iX || A.iY != B.iY;
        }

        /// <summary>2つのiPoint等しいかどうかを返す</summary>
        /// <param name="A">1つ目のiPoint</param>
        /// <param name="B">2つ目のiPoint</param>
        /// <returns>等しかったらtrue、等しくなかったらfalseを返す</returns>
        public static bool operator ==(iPoint A, iPoint B)
        {
            return A.iX == B.iX && A.iY == B.iY;
        }

        /// <summary>iPointからPointに暗黙的に変換する</summary>
        /// <param name="Obj">対象のiPoint</param>
        /// <returns>変換後のPoint</returns>
        public static implicit operator Point(iPoint Obj)
        {
            return new Point(Obj.iX, Obj.iY);
        }

        /// <summary>PointからiPointに明示的に変換する</summary>
        /// <param name="Obj">対象のPoint</param>
        /// <returns>変換後のiPoint</returns>
        public static explicit operator iPoint(Point Obj)
        {
            return new iPoint((int)Obj.X, (int)Obj.Y);
        }
    }
    #endregion

    #region iSize構造体
    /// <summary>int型のSize</summary>
    public struct iSize : IComparable<iSize>, IEquatable<iSize>
    {
        private int iWidth, iHeight;

        /// <summary>幅</summary>
        /// <exception cref="System.ArgumentOutOfRangeException">Widthが0未満の場合に発生する</exception>
        public int Width
        {
            get { return this.iWidth; }

            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("Width", "Widthが0未満に設定されました。");

                this.iWidth = value;
            }
        }

        /// <summary>高さ</summary>
        /// <exception cref="System.ArgumentOutOfRangeException">Heightが0未満の場合に発生する</exception>
        public int Height
        {
            get { return this.iHeight; }
            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("Height", "Heightが0未満に設定されました。");

                this.iHeight = value;
            }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Width">幅</param>
        /// <param name="Height">高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthまたはHeightが0未満の場合に発生する</exception>
        public iSize(int Width, int Height)
        {
            if (Width < 0 || Height < 0)
                throw new ArgumentOutOfRangeException("Width , Height", "WidthまたはHeightが0未満です。");

            this.iWidth = Width;
            this.iHeight = Height;
        }

        /// <summary>iSizeのこのインスタンスのハッシュ コードを取得する</summary>
        /// <returns>iSizeのインスタンスのハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.iWidth ^ this.iHeight;
        }

        /// <summary>現在のインスタンスを表す文字列を返す</summary>
        /// <returns>現在のインスタンスを表す文字列</returns>
        public override string ToString()
        {
            return string.Format("{0},{1}", this.Width, this.Height);
        }

        /// <summary>値がiSizeのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iSizeの現在のインスタンスと比較するiSize</param>
        /// <returns>iSizeのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is iSize))
                return false;

            iSize tmp = (iSize)obj;

            return this.iWidth == tmp.iWidth && this.iHeight == tmp.iHeight;
        }

        /// <summary>値がiSizeのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iSizeの現在のインスタンスと比較するiSize</param>
        /// <returns>iSizeのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public bool Equals(iSize obj)
        {
            return this.iWidth == obj.iWidth && this.iHeight == obj.iHeight;
        }

        /// <summary>指定されたiSizeと比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="value">比較するiSize</param>
        /// <returns>valueと比較して値が大きければ0より大きい値、小さければ0より小さい値、等しければ0を返す</returns>
        public int CompareTo(iSize value)
        {
            return (this.iHeight - value.iHeight) + (this.iWidth - value.iWidth);
        }

        /// <summary>2つのiSize等しくないかどうかを返す</summary>
        /// <param name="A">1つ目のiSize</param>
        /// <param name="B">2つ目のiSize</param>
        /// <returns>等しくなかったらtrue、等しかったらfalseを返す</returns>
        public static bool operator !=(iSize A, iSize B)
        {
            return A.iWidth != B.iWidth || A.iHeight != B.iHeight;
        }

        /// <summary>2つのiSize等しいかどうかを返す</summary>
        /// <param name="A">1つ目のiSize</param>
        /// <param name="B">2つ目のiSize</param>
        /// <returns>等しかったらtrue、等しくなかったらfalseを返す</returns>
        public static bool operator ==(iSize A, iSize B)
        {
            return A.iWidth == B.iWidth && A.iHeight == B.iHeight;
        }

        /// <summary>iSizeからSizeに暗黙的に変換する</summary>
        /// <param name="Obj">対象のiSize</param>
        /// <returns>変換後のSize</returns>
        public static implicit operator Size(iSize Obj)
        {
            return new Size(Obj.iWidth, Obj.iHeight);
        }

        /// <summary>SizeからiSizeに明示的に変換する</summary>
        /// <param name="Obj">対象のSize</param>
        /// <returns>変換後のiSize</returns>
        public static explicit operator iSize(Size Obj)
        {
            return new iSize((int)Math.Ceiling(Obj.Width), (int)Math.Ceiling(Obj.Height));
        }
    }
    #endregion

    #region iRect構造体
    /// <summary>int型のRect</summary>
    public struct iRect : IComparable<iRect>, IEquatable<iRect>
    {
        private iPoint Start, End;
        private iSize Size;

        /// <summary>この長方形の左上の原点のX座標を取得または設定する</summary>
        public int X 
        {
            get { return this.Start.X; }
            set
            {
                this.Start.X = value;
                this.End.X = this.Start.X + this.Size.Width;
            }
        }

        /// <summary>この長方形の左上の原点のY座標を取得または設定する</summary>
        public int Y
        {
            get { return this.Start.Y; }
            set
            {
                this.Start.Y = value;
                this.End.Y = this.Start.Y + this.Size.Height;
            }
        }

        /// <summary>この長方形の幅を取得または設定する(マイナスの場合LeftとRightが反転する)</summary>
        public int Width
        {
            get { return this.Size.Width; }
            set
            {
                this.Size.Width = Math.Abs(value);
                int tmp = this.Start.X + value;

                if (value < 0)
                {
                    this.End.X = this.Start.X;
                    this.Start.X = tmp;
                }

                else
                    this.End.X = tmp;
            }
        }

        /// <summary>この長方形の高さを取得または設定する(マイナスの場合TopとBottomが反転する)</summary>
        public int Height
        {
            get { return this.Size.Height; }
            set
            {
                this.Size.Height = Math.Abs(value);
                int tmp = this.Start.Y + value;

                if (value < 0)
                {
                    this.End.Y = this.Start.Y;
                    this.Start.Y = tmp;
                }

                else
                    this.End.Y = tmp;
            }
        }

        /// <summary>この長方形の左端を取得する</summary>
        public int Left { get { return this.Start.X; } }

        /// <summary>この長方形の上端を取得する</summary>
        public int Top { get { return this.Start.Y; } }

        /// <summary>この長方形の右端を取得する(辺を含まない Left&lt;=X&lt;Right)</summary>
        public int Right { get { return this.End.X; } }

        /// <summary>この長方形の下端を取得する(辺を含まない Top&lt;=Y&lt;Bottom)</summary>
        public int Bottom { get { return this.End.Y; } }

        /// <summary>コンストラクタ</summary>
        /// <param name="Point1">1つ目の座標</param>
        /// <param name="Point2">2つ目の座標</param>
        /// <exception cref="System.ArgumentException">Point1とPoint2が位置関係の条件(左上の点と右下の点でなければならない)に当てはまらなかった場合に発生する</exception>
        public iRect(iPoint Point1, iPoint Point2)
        {
            if ((Point1.X <= Point2.X && Point1.Y > Point2.Y) || (Point1.X > Point2.X && Point1.Y <= Point2.Y))
                throw new ArgumentException("Point1とPoint2の位置関係の条件が守られていません。", "Point1 , Point2");

            this.Start = (Point1.X > Point2.X ? Point2 : Point1);
            this.End = (Point2.X < Point1.X ? Point1 : Point2);
            this.Size = new iSize(this.End.X - this.Start.X, this.End.Y - this.Start.Y);
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Location">長方形の左上端</param>
        /// <param name="Size">長方形のサイズ</param>
        public iRect(iPoint Location, iSize Size)
        {
            this.Start = Location;
            this.Size = Size;
            this.End = new iPoint(Location.X + Size.Width, Location.Y + Size.Height);
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="X">X座標(左端)</param>
        /// <param name="Y">Y座標(上端)</param>
        /// <param name="Width">幅(マイナスの場合Xが右端となる)</param>
        /// <param name="Height">高さ(マイナスの場合Yが下端となる)</param>
        public iRect(int X,int Y,int Width,int Height)
        {
            int EX = X + Width;
            int EY = Y + Height;

            if (X > EX) ExtraClass.Swap(ref X, ref EX);
            if (Y > EY) ExtraClass.Swap(ref Y, ref EY);

            this.Start = new iPoint(X, Y);
            this.Size = new iSize(Math.Abs(Width), Math.Abs(Height));
            this.End = new iPoint(EX, EY);
        }

        /// <summary>iRectのこのインスタンスのハッシュ コードを取得する</summary>
        /// <returns>iRectのインスタンスのハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.Start.GetHashCode() ^ this.Size.GetHashCode();
        }

        /// <summary>現在のインスタンスを表す文字列を返す</summary>
        /// <returns>現在のインスタンスを表す文字列</returns>
        public override string ToString()
        {
            return string.Format("{0},{1},{2},{3}", this.X, this.Y, this.Width, this.Height);
        }

        /// <summary>値がiRectのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iRectの現在のインスタンスと比較するiSize</param>
        /// <returns>iRectのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is iRect))
                return false;

            iRect tmp = (iRect)obj;

            return this.Start == tmp.Start && this.Size == tmp.Size;
        }

        /// <summary>値がiRectのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">iRectの現在のインスタンスと比較するiRect</param>
        /// <returns>iRectのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public bool Equals(iRect obj)
        {
            return this.Start == obj.Start && this.Size == obj.Size;
        }

        /// <summary>指定されたiRectと比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="value">比較するiRect</param>
        /// <returns>valueと比較して値が大きければ0より大きい値、小さければ0より小さい値、等しければ0を返す</returns>
        public int CompareTo(iRect value)
        {
            return this.Start.CompareTo(value.Start) + this.Size.CompareTo(value.Size);
        }

        /// <summary>2つのiRect等しくないかどうかを返す</summary>
        /// <param name="A">1つ目のiRect</param>
        /// <param name="B">2つ目のiRect</param>
        /// <returns>等しくなかったらtrue、等しかったらfalseを返す</returns>
        public static bool operator !=(iRect A, iRect B)
        {
            return A.Start != B.Start || A.Size != B.Size;
        }

        /// <summary>2つのiRect等しいかどうかを返す</summary>
        /// <param name="A">1つ目のiRect</param>
        /// <param name="B">2つ目のiRect</param>
        /// <returns>等しかったらtrue、等しくなかったらfalseを返す</returns>
        public static bool operator ==(iRect A, iRect B)
        {
            return A.Start == B.Start && A.Size == B.Size;
        }

        /// <summary>iRectからRectに暗黙的に変換する</summary>
        /// <param name="Obj">対象のiRect</param>
        /// <returns>変換後のRect</returns>
        public static implicit operator Rect(iRect Obj)
        {
            return new Rect(Obj.Start, Obj.Size);
        }

        /// <summary>RectからiRectに明示的に変換する</summary>
        /// <param name="Obj">対象のRect</param>
        /// <returns>変換後のiRect</returns>
        public static explicit operator iRect(Rect Obj)
        {
            return new iRect((int)Obj.X, (int)Obj.Y, (int)Math.Ceiling(Obj.Width), (int)Math.Ceiling(Obj.Height));
        }
    }
    #endregion

    #region PointRect構造体
    /// <summary>Point型で4点を指定したRect</summary>
    public struct PointRect
    {
        private Point TL, TR, BL, BR;

        /// <summary>この長方形の左上端を取得する</summary>
        public Point TopLeft { get { return this.TL; } }

        /// <summary>この長方形の右上端を取得する</summary>
        public Point TopRight { get { return this.TR; } }

        /// <summary>この長方形の左下端を取得する</summary>
        public Point BottomLeft { get { return this.BL; } }

        /// <summary>この長方形の右下端を取得する</summary>
        public Point BottomRight { get { return this.BR; } }

        /// <summary>この長方形の幅を取得する(斜めであってもX軸方向のサイズ)</summary>
        public double Width { get { return this.BR.X.Max(this.TR.X) - this.TL.X.Min(this.BL.X); } }

        /// <summary>この長方形の高さを取得する(斜めであってもY軸方向のサイズ)</summary>
        public double Height { get { return this.BL.Y.Max(this.BR.Y)  - this.TL.Y.Min(this.TR.Y); } }

        /// <summary>コンストラクタ</summary>
        /// <param name="Point1">左上の座標</param>
        /// <param name="Point2">右上の座標</param>
        /// <param name="Point3">右下の座標</param>
        /// <param name="Point4">左下の座標</param>
        /// <exception cref="System.ArgumentException">点の座標が左右上下の関係がに当てはまらなかった場合、長方形じゃなかった場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">点の座標を配置すると幅および高さが0になる場合に発生</exception>
        public PointRect(Point Point1, Point Point2, Point Point3, Point Point4)
        {
            if ((Point2.X - Point1.X < 0) || (Point3.X - Point4.X < 0))
                throw new ArgumentException("点のX座標の位置関係の条件が守られていません。", "Point1 , Point2 , Point3 , Point4");

            if ((Point4.Y - Point1.Y < 0) || (Point3.Y - Point2.Y < 0))
                throw new ArgumentException("点のX座標の位置関係の条件が守られていません。", "Point1 , Point2 , Point3 , Point4");

            if ((Point2.X - Point1.X != Point3.X - Point4.X) || (Point1.X - Point4.X != Point2.X - Point3.X))
                throw new ArgumentException("点のX座標の位置関係の条件が守られていません。", "Point1 , Point2 , Point3 , Point4");

            if ((Point2.Y - Point1.Y != Point3.Y - Point4.Y) || (Point1.Y - Point4.Y != Point2.Y - Point3.Y))
                throw new ArgumentException("点のY座標の位置関係の条件が守られていません。", "Point1 , Point2 , Point3 , Point4");

            this.TL = Point1;
            this.TR = Point2;
            this.BL = Point3;
            this.BR = Point4;

            if (this.Width == 0 || this.Height == 0)
                throw new ArgumentOutOfRangeException("Point1 , Point2 , Point3 , Point4", "点を配置すると幅か高さが0になります。");
        }

        /// <summary>PointRectのこのインスタンスのハッシュ コードを取得する</summary>
        /// <returns>PointRectのインスタンスのハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.TL.GetHashCode() ^ this.TR.GetHashCode() ^ this.BL.GetHashCode() ^ this.BR.GetHashCode();
        }

        /// <summary>値がPointRectのインスタンスと等しいかどうかを比較する</summary>
        /// <param name="obj">PointRectの現在のインスタンスと比較するPointRect</param>
        /// <returns>PointRectのインスタンスが等しい場合はtrue、それ以外の場合はfalse</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is PointRect)) return false;

            PointRect tmp = (PointRect)obj;

            return (this.TL == tmp.TL) && (this.TR == tmp.TR) && (this.BL == tmp.BL) && (this.BR == tmp.BR);
        }

        /// <summary>2つのPointRect等しくないかどうかを返す</summary>
        /// <param name="A">1つ目のPointRect</param>
        /// <param name="B">2つ目のPointRect</param>
        /// <returns>等しくなかったらtrue、それ以外はfalseを返す</returns>
        public static bool operator !=(PointRect A, PointRect B)
        {
            return (A.TL != B.TL) || (A.TR != B.TR) || (A.BL != B.BL) || (A.BR != B.BR);
        }

        /// <summary>2つのiRect等しいかどうかを返す</summary>
        /// <param name="A">1つ目のPointRect</param>
        /// <param name="B">2つ目のPointRect</param>
        /// <returns>等しかったらtrue、それ以外はfalseを返す</returns>
        public static bool operator ==(PointRect A, PointRect B)
        {
            return (A.TL == B.TL) && (A.TR == B.TR) && (A.BL == B.BL) && (A.BR == B.BR);
        }

        /// <summary>PointRectからPoint配列に暗黙的に変換する</summary>
        /// <param name="Obj">対象のPointRect</param>
        /// <returns>変換後のPoint</returns>
        public static implicit operator Point[](PointRect Obj)
        {
            return new Point[] { Obj.TL, Obj.TR, Obj.BL, Obj.BR };
        }
    }
    #endregion

    #region NeverWherePluralsValue構造体

    #region 2個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
        }
    }
    #endregion

    #region 3個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
        }
    }
    #endregion

    #region 4個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
        }
    }
    #endregion

    #region 5個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
        }
    }
    #endregion

    #region 6個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4, T5>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
        }
    }
    #endregion

    #region 7個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4, T5, T6>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
        }
    }
    #endregion

    #region 8個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4, T5, T6, T7>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
        }
    }
    #endregion

    #region 9個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    /// <typeparam name="T8">保持する9個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>9個目の値</summary>
        public T8 NinthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        /// <param name="NinthValue">9個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue, T8 NinthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
            this.NinthValue = NinthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
            yield return this.NinthValue;
        }
    }
    #endregion

    #region 10個
    /// <summary>複数の値を保持する型の制限のない構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    /// <typeparam name="T8">保持する9個目の型</typeparam>
    /// <typeparam name="T9">保持する10個目の型</typeparam>
    public struct NeverWherePluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>9個目の値</summary>
        public T8 NinthValue;

        /// <summary>10個目の値</summary>
        public T9 TenthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        /// <param name="NinthValue">9個目の値</param>
        /// <param name="TenthValue">10個目の値</param>
        public NeverWherePluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue, T8 NinthValue, T9 TenthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
            this.NinthValue = NinthValue;
            this.TenthValue = TenthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
            yield return this.NinthValue;
            yield return this.TenthValue;
        }
    }
    #endregion

    #endregion

    #region PluralsValue構造体

    #region 2個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    public struct PluralsValue<T0, T1> : IComparable<PluralsValue<T0, T1>>, IEquatable<PluralsValue<T0, T1>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 2)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 2)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 3個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2> : IComparable<PluralsValue<T0, T1, T2>>, IEquatable<PluralsValue<T0, T1, T2>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 3)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 3)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 4個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3> : IComparable<PluralsValue<T0, T1, T2, T3>>, IEquatable<PluralsValue<T0, T1, T2, T3>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 4)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 4)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 5個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4> : IComparable<PluralsValue<T0, T1, T2, T3, T4>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 5)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 5)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 6個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4, T5> : IComparable<PluralsValue<T0, T1, T2, T3, T4, T5>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4, T5>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
        where T5 : IComparable<T5>, IEquatable<T5>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4, T5> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 6)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4, T5> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 6)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 7個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4, T5, T6> : IComparable<PluralsValue<T0, T1, T2, T3, T4, T5, T6>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4, T5, T6>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
        where T5 : IComparable<T5>, IEquatable<T5>
        where T6 : IComparable<T6>, IEquatable<T6>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4, T5, T6> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 7)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4, T5, T6> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 7)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 8個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7> : IComparable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
        where T5 : IComparable<T5>, IEquatable<T5>
        where T6 : IComparable<T6>, IEquatable<T6>
        where T7 : IComparable<T7>, IEquatable<T7>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 8)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 8)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 9個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    /// <typeparam name="T8">保持する9個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8> : IComparable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
        where T5 : IComparable<T5>, IEquatable<T5>
        where T6 : IComparable<T6>, IEquatable<T6>
        where T7 : IComparable<T7>, IEquatable<T7>
        where T8 : IComparable<T8>, IEquatable<T8>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>9個目の値</summary>
        public T8 NinthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        /// <param name="NinthValue">9個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue, T8 NinthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
            this.NinthValue = NinthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
            yield return this.NinthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 9)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 8:
                        {
                            T8 a = (T8)A.Current;
                            T8 b = (T8)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0 && cnt < 9)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 8:
                        {
                            T8 a = (T8)A.Current;
                            T8 b = (T8)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region 10個
    /// <summary>複数の値を保持する構造体</summary>
    /// <typeparam name="T0">保持する1個目の型</typeparam>
    /// <typeparam name="T1">保持する2個目の型</typeparam>
    /// <typeparam name="T2">保持する3個目の型</typeparam>
    /// <typeparam name="T3">保持する4個目の型</typeparam>
    /// <typeparam name="T4">保持する5個目の型</typeparam>
    /// <typeparam name="T5">保持する6個目の型</typeparam>
    /// <typeparam name="T6">保持する7個目の型</typeparam>
    /// <typeparam name="T7">保持する8個目の型</typeparam>
    /// <typeparam name="T8">保持する9個目の型</typeparam>
    /// <typeparam name="T9">保持する10個目の型</typeparam>
    public struct PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : IComparable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>, IEquatable<PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>
        where T0 : IComparable<T0>, IEquatable<T0>
        where T1 : IComparable<T1>, IEquatable<T1>
        where T2 : IComparable<T2>, IEquatable<T2>
        where T3 : IComparable<T3>, IEquatable<T3>
        where T4 : IComparable<T4>, IEquatable<T4>
        where T5 : IComparable<T5>, IEquatable<T5>
        where T6 : IComparable<T6>, IEquatable<T6>
        where T7 : IComparable<T7>, IEquatable<T7>
        where T8 : IComparable<T8>, IEquatable<T8>
        where T9 : IComparable<T9>, IEquatable<T9>
    {
        /// <summary>1個目の値</summary>
        public T0 FirstValue;

        /// <summary>2個目の値</summary>
        public T1 SecondValue;

        /// <summary>3個目の値</summary>
        public T2 ThirdValue;

        /// <summary>4個目の値</summary>
        public T3 FourthValue;

        /// <summary>5個目の値</summary>
        public T4 FifthValue;

        /// <summary>6個目の値</summary>
        public T5 SixthValue;

        /// <summary>7個目の値</summary>
        public T6 SeventhValue;

        /// <summary>8個目の値</summary>
        public T7 EighthValue;

        /// <summary>9個目の値</summary>
        public T8 NinthValue;

        /// <summary>10個目の値</summary>
        public T9 TenthValue;

        /// <summary>コンストラクタ</summary>
        /// <param name="FirstValue">1個目の値</param>
        /// <param name="SecondValue">2個目の値</param>
        /// <param name="ThirdValue">3個目の値</param>
        /// <param name="FourthValue">4個目の値</param>
        /// <param name="FifthValue">5個目の値</param>
        /// <param name="SixthValue">6個目の値</param>
        /// <param name="SeventhValue">7個目の値</param>
        /// <param name="EighthValue">8個目の値</param>
        /// <param name="NinthValue">9個目の値</param>
        /// <param name="TenthValue">10個目の値</param>
        public PluralsValue(T0 FirstValue, T1 SecondValue, T2 ThirdValue, T3 FourthValue, T4 FifthValue, T5 SixthValue, T6 SeventhValue, T7 EighthValue, T8 NinthValue, T9 TenthValue)
        {
            this.FirstValue = FirstValue;
            this.SecondValue = SecondValue;
            this.ThirdValue = ThirdValue;
            this.FourthValue = FourthValue;
            this.FifthValue = FifthValue;
            this.SixthValue = SixthValue;
            this.SeventhValue = SeventhValue;
            this.EighthValue = EighthValue;
            this.NinthValue = NinthValue;
            this.TenthValue = TenthValue;
        }

        /// <summary>Iteratorオブジェクトを返す</summary>
        /// <returns>Iteratorオブジェクト</returns>
        public System.Collections.IEnumerable GetIterator()
        {
            yield return this.FirstValue;
            yield return this.SecondValue;
            yield return this.ThirdValue;
            yield return this.FourthValue;
            yield return this.FifthValue;
            yield return this.SixthValue;
            yield return this.SeventhValue;
            yield return this.EighthValue;
            yield return this.NinthValue;
            yield return this.TenthValue;
        }

        #region 比較
        /// <summary>このインスタンスが、指定したPluralsValueの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するPluralsValue</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> obj)
        {
            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;
            bool res = true;

            while (res && cnt < 10)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 8:
                        {
                            T8 a = (T8)A.Current;
                            T8 b = (T8)B.Current;
                            res = a.Equals(b);
                        }
                        break;

                    case 9:
                        {
                            T9 a = (T9)A.Current;
                            T9 b = (T9)B.Current;
                            res = a.Equals(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }

        /// <summary>指定したPluralsValueとこのインスタンスを比較し、指定したPluralsValueの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のPluralsValue</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(PluralsValue<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> obj)
        {
            int res = 0;

            var A = this.GetIterator().GetEnumerator();
            var B = obj.GetIterator().GetEnumerator();
            int cnt = 0;

            while (res == 0&& cnt<10)
            {
                A.MoveNext(); B.MoveNext();

                switch (cnt)
                {
                    case 0:
                        {
                            T0 a = (T0)A.Current;
                            T0 b = (T0)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 1:
                        {
                            T1 a = (T1)A.Current;
                            T1 b = (T1)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 2:
                        {
                            T2 a = (T2)A.Current;
                            T2 b = (T2)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 3:
                        {
                            T3 a = (T3)A.Current;
                            T3 b = (T3)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 4:
                        {
                            T4 a = (T4)A.Current;
                            T4 b = (T4)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 5:
                        {
                            T5 a = (T5)A.Current;
                            T5 b = (T5)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 6:
                        {
                            T6 a = (T6)A.Current;
                            T6 b = (T6)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 7:
                        {
                            T7 a = (T7)A.Current;
                            T7 b = (T7)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 8:
                        {
                            T8 a = (T8)A.Current;
                            T8 b = (T8)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;

                    case 9:
                        {
                            T9 a = (T9)A.Current;
                            T9 b = (T9)B.Current;
                            res = a.CompareTo(b);
                        }
                        break;
                }

                cnt++;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #endregion

    #region FixPoint構造体
    /// <summary>固定小数表記での座標を表す構造体</summary>
    internal struct FixPoint : IComparable, IComparable<FixPoint>, IEquatable<FixPoint>
    {
        /// <summary>座標値X</summary>
        public int X;

        /// <summary>座標値Y</summary>
        public int Y;

        /// <summary>Xの整数部のみを抽出して返す</summary>
        public int XIntPart { get { return this.X.iPart(); } }

        /// <summary>Yの整数部のみを抽出して返す</summary>
        public int YIntPart { get { return this.Y.iPart(); } }

        /// <summary>Xの小数部のみを抽出して返す</summary>
        public int XFrtPart { get { return this.X.fPart(); } }

        /// <summary>Yの小数部のみを抽出して返す</summary>
        public int YFrtPart { get { return this.Y.fPart(); } }

        /// <summary>初期値を与えてオブジェクトを生成する</summary>
        /// <param name="X">座標X</param>
        /// <param name="Y">座標Y</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        public FixPoint(double X, double Y, FixPointConstants Mode)
        {
            switch (Mode)
            {
                case FixPointConstants.FixBoth:
                    this.X = X.ToFix();
                    this.Y = Y.ToFix();
                    break;

                case FixPointConstants.FixX:
                    this.X = X.ToFix();
                    this.Y = (int)Y;
                    break;

                case FixPointConstants.FixY:
                    this.X = (int)X;
                    this.Y = Y.ToFix();
                    break;

                case FixPointConstants.NonFix:
                    this.X = (int)X;
                    this.Y = (int)Y;
                    break;

                default:
                    this.X = X.ToFix();
                    this.Y = Y.ToFix();
                    break;
            }
        }

        /// <summary>初期値を与えてオブジェクトを生成する</summary>
        /// <param name="P">座標P</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        public FixPoint(Point P, FixPointConstants Mode)
        {
            switch (Mode)
            {
                case FixPointConstants.FixBoth:
                    this.X = P.X.ToFix();
                    this.Y = P.Y.ToFix();
                    break;

                case FixPointConstants.FixX:
                    this.X = P.X.ToFix();
                    this.Y = (int)P.Y;
                    break;

                case FixPointConstants.FixY:
                    this.X = (int)P.X;
                    this.Y = P.Y.ToFix();
                    break;

                case FixPointConstants.NonFix:
                    this.X = (int)P.X;
                    this.Y = (int)P.Y;
                    break;

                default:
                    this.X = P.X.ToFix();
                    this.Y = P.Y.ToFix();
                    break;
            }
        }

        /// <summary>初期値を与えてオブジェクトを生成する</summary>
        /// <param name="FixX">固定小数表記の座標X</param>
        /// <param name="FixY">固定小数表記の座標Y</param>
        public FixPoint(int FixX, int FixY)
        {
            this.X = FixX;
            this.Y = FixY;
        }

        /// <summary>このインスタンスのハッシュコードを返す</summary>
        /// <returns>32 ビット符号付き整数ハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.Y ^ this.X;
        }

        /// <summary>iPoint形式に変換する</summary>
        /// <param name="Obj">変換対象のオブジェクト</param>
        /// <returns>変換後のiPoint</returns>
        public static implicit operator iPoint(FixPoint Obj)
        {
            return new iPoint(Obj.X, Obj.Y);
        }

        /// <summary>iPointをFixPointに固定小数表記なしで変換する</summary>
        /// <param name="Obj">変換対象のオブジェクト</param>
        /// <returns>変換後のFixPoint</returns>
        public static implicit operator FixPoint(iPoint Obj)
        {
            return new FixPoint(Obj, FixPointConstants.NonFix);
        }

        #region 比較演算子のオーバーロード・比較メソッド
        /// <summary>指定した2つのFixPointの値が等しいかどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>AとBが同じ値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator ==(FixPoint A, FixPoint B)
        {
            return A.Y == B.Y && A.X == B.X;
        }

        /// <summary>指定した2つのFixPointの値が等しいかどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>AとBが同じ値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator !=(FixPoint A, FixPoint B)
        {
            return A.Y != B.Y || A.X != B.X;
        }

        /// <summary>指定した2つのFixPointの値が右側の方が大きいかどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>AよりBが大きい値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator <(FixPoint A, FixPoint B)
        {
            if (A.Y < B.Y)
                return true;

            else if (A.Y > B.Y)
                return false;

            else
            {
                if (A.X < B.X)
                    return true;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixPointの値が左側の方が大きいかどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>BよりAが大きい値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator >(FixPoint A, FixPoint B)
        {
            if (A.Y > B.Y)
                return true;

            else if (A.Y < B.Y)
                return false;

            else
            {
                if (A.X > B.X)
                    return true;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixPointの値が右側の値以上かどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>AがB以上の値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator <=(FixPoint A, FixPoint B)
        {
            if (A.Y < B.Y)
                return true;

            else if (A.Y > B.Y)
                return false;

            else
            {
                if (A.X < B.X)
                    return true;

                else if (A.X > B.X)
                    return false;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixPointの値が左側の値以上かどうかを返す</summary>
        /// <param name="A">1つめFixPoint</param>
        /// <param name="B">2つめFixPoint</param>
        /// <returns>BがA以上の値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator >=(FixPoint A, FixPoint B)
        {
            if (A.Y > B.Y)
                return true;

            else if (A.Y < B.Y)
                return false;

            else
            {
                if (A.X > B.X)
                    return true;

                else if (A.X < B.X)
                    return false;

                else
                    return false;
            }
        }

        /// <summary>このインスタンスが、指定したオブジェクトに等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するオブジェクト</param>
        /// <returns>obj がFixPointのインスタンスでこのインスタンスに等しい場合は true、それ以外の場合は false</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is FixPoint))
                return false;

            FixPoint tmp = (FixPoint)obj;

            return this.Y == tmp.Y && this.X == tmp.X;
        }

        /// <summary>このインスタンスが、指定したFixPointの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するFixPoint</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(FixPoint obj)
        {
            return this.Y == obj.Y && this.X == obj.X;
        }

        /// <summary>指定したオブジェクトとこのインスタンスを比較し、指定したオブジェクトの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="value">比較対象のオブジェクト、または null。</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている またはvalue が null</returns>
        public int CompareTo(Object value)
        {
            if (value == null)
                return 1;

            FixPoint obj;

            try
            {
                obj = (FixPoint)value;
            }
            catch (Exception)
            {
                throw new System.ArgumentException("型変換に失敗しました。");
            }


            int res;

            if (this.Y < obj.Y)
                res = -1;

            else if (this.Y > obj.Y)
                res = 1;

            else
            {
                if (this.X < obj.X)
                    res = -1;

                else if (this.X > obj.X)
                    res = 1;

                else
                    res = 0;
            }

            return res;
        }

        /// <summary>指定した FixPointとこのインスタンスを比較し、指定した FixPointの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のFixPoint</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(FixPoint obj)
        {
            int res;

            if (this.Y < obj.Y)
                res = -1;

            else if (this.Y > obj.Y)
                res = 1;

            else
            {
                if (this.X < obj.X)
                    res = -1;

                else if (this.X > obj.X)
                    res = 1;

                else
                    res = 0;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region FixLineクラス
    /// <summary>固定小数表記(16:16)で表した線を表すクラス</summary>
    internal class FixLine : IComparable, IComparable<FixLine>, IEquatable<FixLine>
    {
        /// <summary>固定小数表記の始点</summary>
        public FixPoint Start;

        /// <summary>固定小数表記の終点</summary>
        public FixPoint End;

        /// <summary>固定小数表記の比較する始点</summary>
        public FixPoint CompareStart;

        /// <summary>固定小数表記の比較する終点</summary>
        public FixPoint CompareEnd;

        /// <summary>X軸の辺の傾き(無限大のときはint.MaxValue)</summary>
        public int AddX;

        /// <summary>Y軸の辺の傾き(無限大のときはint.MaxValue)</summary>
        public int AddY;

        /// <summary>現在位置のX</summary>
        public int X;

        /// <summary>現在位置のY</summary>
        public int Y;

        /// <summary>この辺の傾きが上か下か</summary>
        public bool IsUpperSide;

        /// <summary>始点と終点を反転させたかどうか</summary>
        public bool ReverseValue;

        /// <summary>計算を始めたかどうか</summary>
        private bool CalcStart;

        /// <summary>現在位置をiPoint形式で返す</summary>
        public iPoint Point
        {
            get { return new iPoint(this.X, this.Y); }
        }

        #region 初期化・コンストラクタ等
        /// <summary>コンストラクタ</summary>
        private FixLine()
        {
            this.CalcStart = false;
        }

        private void Init(FixPoint Start, FixPoint End, int AddX, int AddY, bool IsXLine)
        {
            this.AddX = (AddY == int.MaxValue ? 0 : AddX);
            this.AddY = (AddX == int.MaxValue ? 0 : AddY);

            if (IsXLine)
            {
                if (Start.Y == End.Y)
                {
                    if (Start.X < End.X)
                    {
                        this.Start = Start;
                        this.End = End;
                    }

                    else
                    {
                        this.Start = End;
                        this.End = Start;
                    }
                }

                else if (Start.Y < End.Y)
                {
                    this.Start = Start;
                    this.End = End;
                }

                else
                {
                    this.Start = End;
                    this.End = Start;
                }
            }

            else
            {
                if (Start.X == End.X)
                {
                    if (Start.Y < End.Y)
                    {
                        this.Start = Start;
                        this.End = End;
                    }

                    else
                    {
                        this.Start = End;
                        this.End = Start;
                    }
                }

                else if (Start.X < End.X)
                {
                    this.Start = Start;
                    this.End = End;
                }

                else
                {
                    this.Start = End;
                    this.End = Start;
                }
            }

            this.X = this.Start.X;
            this.Y = this.Start.Y;
            this.CompareStart = this.Start;
            this.CompareEnd = this.End;

            if (this.Start != Start)
                this.ReverseValue = true;
        }

        /// <summary>横線を与えてオブジェクトを生成する、その際辺の傾き方向も求める</summary>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromXLine(double StartX, double StartY, double EndX, double EndY, FixPointConstants Mode)
        {
            FixLine res = new FixLine();
            int add = (StartY != EndY ? ((EndX - StartX) / (EndY - StartY)).ToFix() : int.MaxValue);

            res.IsUpperSide = EndY > StartY;

            res.Init(new FixPoint(StartX, StartY, Mode), new FixPoint(EndX, EndY, Mode), add, 1.ToFix(), true);

            return res;
        }

        /// <summary>横線を与えてオブジェクトを生成する、その際辺の傾き方向も求める</summary>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromXLine(Point Start, Point End, FixPointConstants Mode)
        {
            FixLine res = new FixLine();
            int add = (Start.Y != End.Y ? ((End.X - Start.X) / (End.Y - Start.Y)).ToFix() : int.MaxValue);

            res.IsUpperSide = End.Y > Start.Y;

            res.Init(new FixPoint(Start, Mode), new FixPoint(End, Mode), add, 1.ToFix(), true);

            return res;
        }

        /// <summary>横線を与えてオブジェクトを生成する、その際辺の傾き方向も求める(通常X軸の傾きをn、Y方向の傾きを1とする)</summary>
        /// <param name="FixStartX">固定小数表記の始点X</param>
        /// <param name="FixStartY">固定小数表記の始点Y</param>
        /// <param name="FixEndX">固定小数表記の終点X</param>
        /// <param name="FixEndY">固定小数表記の終点Y</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromXLine(int FixStartX, int FixStartY, int FixEndX, int FixEndY)
        {
            FixLine res = new FixLine();
            int add = (FixStartY != FixEndY ? ((double)(FixEndX - FixStartX) / (double)(FixEndY - FixStartY)).ToFix() : int.MaxValue);

            res.IsUpperSide = FixEndY > FixStartY;

            res.Init(new FixPoint(FixStartX, FixStartY), new FixPoint(FixEndX, FixEndY), add, 1.ToFix(), true);

            return res;
        }

        /// <summary>縦線を与えてオブジェクトを生成する、その際辺の傾き方向も求める</summary>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromYLine(double StartX, double StartY, double EndX, double EndY, FixPointConstants Mode)
        {
            FixLine res = new FixLine();
            int add = (StartX != EndX ? ((EndY - StartY) / (EndX - StartX)).ToFix() : int.MaxValue);

            res.IsUpperSide = EndX > StartX;

            res.Init(new FixPoint(StartX, StartY, Mode), new FixPoint(EndX, EndY, Mode), 1.ToFix(), add, false);

            return res;
        }

        /// <summary>縦線を与えてオブジェクトを生成する、その際辺の傾き方向も求める</summary>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        /// <param name="Mode">固定小数の設定をどうするか</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromYLine(Point Start, Point End, FixPointConstants Mode)
        {
            FixLine res = new FixLine();
            int add = (Start.X != End.X ? ((End.Y - Start.Y) / (End.X - Start.X)).ToFix() : int.MaxValue);

            res.IsUpperSide = End.X > Start.X;

            res.Init(new FixPoint(Start, Mode), new FixPoint(End, Mode), 1.ToFix(), add, false);

            return res;
        }

        /// <summary>縦線を与えてオブジェクトを生成する、その際辺の傾き方向も求める(通常X軸の傾きをn、Y方向の傾きを1とする)</summary>
        /// <param name="FixStartX">固定小数表記の始点X</param>
        /// <param name="FixStartY">固定小数表記の始点Y</param>
        /// <param name="FixEndX">固定小数表記の終点X</param>
        /// <param name="FixEndY">固定小数表記の終点Y</param>
        /// <returns>生成されたオブジェクト</returns>
        public static FixLine FromYLine(int FixStartX, int FixStartY, int FixEndX, int FixEndY)
        {
            FixLine res = new FixLine();
            int add = (FixStartX != FixEndX ? ((double)(FixEndY - FixStartY) / (double)(FixEndX - FixStartX)).ToFix() : int.MaxValue);

            res.IsUpperSide = FixEndX > FixStartX;

            res.Init(new FixPoint(FixStartX, FixStartY), new FixPoint(FixEndX, FixEndY), 1.ToFix(), add, false);

            return res;
        }
        #endregion

        /// <summary>X方向にClippingする</summary>
        /// <param name="MinX">最小値</param>
        /// <param name="MaxX">最大値</param>
        /// <returns>描画対象外かどうか</returns>
        public bool ClippingX(int MinX, int MaxX)
        {
            if (this.End.X < MinX)
                return true;

            else if (this.Start.X > MaxX)
                return true;

            if (this.Start.X < MinX)
            {
                this.Y += this.AddY * (MinX - this.Start.X);
                this.Start.X = MinX;
            }

            if (this.End.X > MaxX)
                this.End.X = MaxX;

            return false;
        }

        /// <summary>Y軸方向にClippingする</summary>
        /// <param name="MinY">最小値</param>
        /// <param name="MaxY">最大値</param>
        /// <returns>描画対象外かどうか</returns>
        public bool ClippingY(int MinY, int MaxY)
        {
            if (this.End.Y < MinY)
                return true;

            else if (this.Start.Y > MaxY)
                return true;

            if (this.Start.Y < MinY)
            {
                this.X += this.AddX * (MinY - this.Start.Y);
                this.Start.Y = MinY;
            }

            if (this.End.Y > MaxY)
                this.End.Y = MaxY;

            return false;
        }

        /// <summary>現在の座標で計算しても良いかどうかを返すと同時に現在位置の計算も行う</summary>
        /// <param name="X">現在のX座標</param>
        /// <param name="Y">現在のY座標</param>
        /// <returns>計算できるかどうか(片方でも軸の傾きがint.MaxValueだった場合常にfalseが返る)</returns>
        public bool IsCalcBoth(int X, int Y)
        {
            if (this.AddX == int.MaxValue || this.AddY == int.MaxValue)
                return false;

            if ((this.CompareStart.X <= X && X < this.CompareEnd.X) && (this.CompareStart.Y <= Y && Y < this.CompareEnd.Y))
            {
                if (!this.CalcStart)
                    this.CalcStart = true;

                else
                {
                    this.X += this.AddX;
                    this.Y += this.AddY;
                }

                return true;
            }

            return false;
        }

        /// <summary>現在のX位置で計算しても良いかどうかを返すと同時に現在位置Yの計算も行う</summary>
        /// <param name="X">現在のX座標</param>
        /// <returns>計算できるかどうか</returns>
        public bool IsCalcX(int X)
        {
            if (this.AddY == int.MaxValue && this.CompareStart.X == X)
                return true;

            else if (this.AddY != int.MaxValue && this.CompareStart.X <= X && X < this.CompareEnd.X)
            {
                if (!this.CalcStart)
                    this.CalcStart = true;

                else
                    this.Y += this.AddY;

                return true;
            }

            return false;
        }

        /// <summary>現在のY位置で計算しても良いかどうかを返すと同時に現在位置Xの計算も行う</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>計算できるかどうか</returns>
        public bool IsCalcY(int Y)
        {
            if (this.AddX == int.MaxValue && this.CompareStart.Y == Y)
                return true;

            else if (this.AddX != int.MaxValue && this.CompareStart.Y <= Y && Y < this.CompareEnd.Y)
            {
                if (!this.CalcStart)
                    this.CalcStart = true;

                else
                    this.X += this.AddX;

                return true;
            }

            return false;
        }

        /// <summary>現在のX位置で計算しても良いかどうかを返すと同時に現在位置の計算も行う</summary>
        /// <param name="X">現在のX座標</param>
        /// <returns>計算できるかどうか</returns>
        public bool IsCalcXBoth(int X)
        {
            if (this.AddY == int.MaxValue && this.CompareStart.X == X)
                return true;

            else if (this.AddY != int.MaxValue && this.CompareStart.X <= X && X < this.CompareEnd.X)
            {
                if (!this.CalcStart)
                    this.CalcStart = true;

                else
                {
                    this.X += this.AddX;
                    this.Y += this.AddY;
                }

                return true;
            }

            return false;
        }

        /// <summary>現在のY位置で計算しても良いかどうかを返すと同時に現在位置の計算も行う</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>計算できるかどうか</returns>
        public bool IsCalcYBoth(int Y)
        {
            if (this.AddX == int.MaxValue && this.CompareStart.Y == Y)
                return true;

            else if (this.AddX != int.MaxValue && this.CompareStart.Y <= Y && Y < this.CompareEnd.Y)
            {
                if (!this.CalcStart)
                    this.CalcStart = true;

                else
                {
                    this.X += this.AddX;
                    this.Y += this.AddY;
                }

                return true;
            }

            return false;
        }

        /// <summary>このインスタンスのハッシュコードを返す</summary>
        /// <returns>32 ビット符号付き整数ハッシュコード</returns>
        public override int GetHashCode()
        {
            return this.Start.GetHashCode() ^ this.End.GetHashCode();
        }

        #region 比較演算子のオーバーロード・比較メソッド
        /// <summary>指定した2つのFixLineの値が等しいかどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>AとBが同じ値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator ==(FixLine A, FixLine B)
        {
            return A.Start.Equals(B.Start) && A.End.Equals(B.End);
        }

        /// <summary>指定した2つのFixLineの値が等しいかどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>AとBが同じ値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator !=(FixLine A, FixLine B)
        {
            return !A.Start.Equals(B.Start) || !A.End.Equals(B.End);
        }

        /// <summary>指定した2つのFixLineの値が右側の方が大きいかどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>AよりBが大きい値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator <(FixLine A, FixLine B)
        {
            if (A.Start < B.Start)
                return true;

            else if (A.Start > B.Start)
                return false;

            else
            {
                if (A.End < B.End)
                    return true;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixLineの値が左側の方が大きいかどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>BよりAが大きい値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator >(FixLine A, FixLine B)
        {
            if (A.Start > B.Start)
                return true;

            else if (A.Start < B.Start)
                return false;

            else
            {
                if (A.End > B.End)
                    return true;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixLineの値が右側の値以上かどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>AがB以上の値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator <=(FixLine A, FixLine B)
        {
            if (A.Start < B.Start)
                return true;

            else if (A.Start > B.Start)
                return false;

            else
            {
                if (A.End < B.End)
                    return true;

                else if (A.End > B.End)
                    return false;

                else
                    return false;
            }
        }

        /// <summary>指定した2つのFixLineの値が左側の値以上かどうかを返す</summary>
        /// <param name="A">1つめFixLine</param>
        /// <param name="B">2つめFixLine</param>
        /// <returns>BがA以上の値を保持している場合は true、それ以外の場合は false</returns>
        public static bool operator >=(FixLine A, FixLine B)
        {
            if (A.Start > B.Start)
                return true;

            else if (A.Start < B.Start)
                return false;

            else
            {
                if (A.End > B.End)
                    return true;

                else if (A.End < B.End)
                    return false;

                else
                    return false;
            }
        }

        /// <summary>このインスタンスが、指定したFixPointの値と等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するFixPoint</param>
        /// <returns>obj がこのインスタンスと同じ値を保持している場合は true、それ以外の場合は false</returns>
        public bool Equals(FixLine obj)
        {
            return this.Start.Equals(obj.Start) && this.End.Equals(obj.End);
        }

        /// <summary>このインスタンスが、指定したオブジェクトに等しいかどうかを返す</summary>
        /// <param name="obj">このインスタンスと比較するオブジェクト</param>
        /// <returns>obj がFixLineのインスタンスでこのインスタンスに等しい場合は true、それ以外の場合は false</returns>
        public override bool Equals(object obj)
        {
            if (!(obj is FixLine))
                return false;

            FixLine tmp = (FixLine)obj;

            return this.Start.Equals(tmp.Start) && this.End.Equals(tmp.End);
        }

        /// <summary>指定したオブジェクトとこのインスタンスを比較し、指定したオブジェクトの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="value">比較対象のオブジェクト、または null。</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている またはvalue が null</returns>
        public int CompareTo(Object value)
        {
            if (value == null)
                return 1;

            FixLine obj;

            try
            {
                obj = (FixLine)value;
            }
            catch (System.ArgumentException e)
            {
                throw e;
            }


            int res;

            if (this.Start < obj.Start)
                res = -1;

            else if (this.Start > obj.Start)
                res = 1;

            else
            {
                if (this.End < obj.End)
                    res = -1;

                else if (this.End > obj.End)
                    res = 1;

                else
                    res = 0;
            }

            return res;
        }

        /// <summary>指定した FixLineとこのインスタンスを比較し、指定した FixPointの値と比べて、このインスタンスの値が大きい、小さい、または等しいかを示す整数を返す</summary>
        /// <param name="obj">比較対象のFixLine</param>
        /// <returns>このインスタンスと value の相対値を示す符号付き数値 戻り値説明 0 より小 このインスタンスは value より小さいことを表す 0 このインスタンスはvalue と等価 0 より大 このインスタンスは value よりも大きくなっている</returns>
        public int CompareTo(FixLine obj)
        {
            int res;

            if (this.Start < obj.Start)
                res = -1;

            else if (this.Start > obj.Start)
                res = 1;

            else
            {
                if (this.End < obj.End)
                    res = -1;

                else if (this.End > obj.End)
                    res = 1;

                else
                    res = 0;
            }

            return res;
        }
        #endregion
    }
    #endregion

    #region FixLineCalcクラス
    /// <summary>FixLineCalcクラス</summary>
    internal class FixLineCalc
    {
        /// <summary>計算に使用する辺のリスト</summary>
        private System.Collections.Generic.List<FixLine> SideList;

        /// <summary>コンストラクタ</summary>
        /// <param name="SideList">辺情報の配列</param>
        public FixLineCalc(System.Collections.Generic.List<FixLine> SideList)
        {
            this.SideList = SideList;
        }

        /// <summary>全ての辺情報をClippingすると共に要らない辺情報をカットする</summary>
        /// <param name="MinY">最小値</param>
        /// <param name="MaxY">最大値</param>
        public void Clipping(int MinY, int MaxY)
        {
            for (int i = 0; i < this.SideList.Count; i++)
            {
                if (this.SideList[i].ClippingY(MinY, MaxY))
                {
                    SideList.RemoveAt(i);
                    i--;
                }
            }
        }

        /// <summary>現在のY位置でのX座標を全て返す</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public System.Collections.Generic.List<int> NowLine(int Y)
        {
            Collections.Generic.List<int> res = new System.Collections.Generic.List<int>();

            for (int i = 0; i < this.SideList.Count; i++)
            {
                if (this.SideList[i].IsCalcY(Y))
                {
                    res.Add(this.SideList[i].X);

                    if (this.SideList[i].AddX == int.MaxValue)
                        res.Add(this.SideList[i].End.X);
                }
            }

            res.Sort();

            return res;
        }

        /// <summary>現在のY位置でのX座標を全て返す(傾き情報も含めて：FirstValueにX座標、SecondValueに傾きが入っている)</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public System.Collections.Generic.List<PluralsValue<int, int>> NowLineAA(int Y)
        {
            Collections.Generic.List<PluralsValue<int, int>> res = new System.Collections.Generic.List<PluralsValue<int, int>>();

            for (int i = 0; i < this.SideList.Count; i++)
            {
                if (this.SideList[i].IsCalcY(Y))
                {
                    if (this.SideList[i].AddX == int.MaxValue)
                    {
                        res.Add(new PluralsValue<int, int>(this.SideList[i].X, 0));
                        res.Add(new PluralsValue<int, int>(this.SideList[i].End.X, 0));
                    }

                    else
                        res.Add(new PluralsValue<int, int>(this.SideList[i].X, this.SideList[i].AddX));
                }
            }

            res.Sort();

            return res;
        }

        /// <summary>現在のY位置でのX座標を非ゼロ回転数規則アルゴリズムに則って返す</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public System.Collections.Generic.List<int> RollNowLine(int Y)
        {
            Collections.Generic.List<PluralsValue<int, bool>> res = new System.Collections.Generic.List<PluralsValue<int, bool>>();
            Collections.Generic.List<int> ires = new System.Collections.Generic.List<int>();

            int cnt;
            int backNum = -1;

            for (int i = 0; i < this.SideList.Count; i++)
            {
                if (this.SideList[i].IsCalcY(Y))
                {
                    res.Add(new PluralsValue<int, bool>(this.SideList[i].X, this.SideList[i].IsUpperSide));

                    if (this.SideList[i].AddX == int.MaxValue)
                        res.Add(new PluralsValue<int, bool>(this.SideList[i].End.X, this.SideList[i].IsUpperSide));
                }
            }

            res.Sort();

            for (int i = 0; i < res.Count - 1; i++)
            {
                cnt = 0;

                for (int j = 0; j <= i; j++)
                {
                    if (res[j].SecondValue) cnt++;
                    else cnt--;
                }

                if (cnt == 0)
                    continue;

                if (i == backNum)
                {
                    ires.RemoveAt(ires.Count - 1);
                    ires.Add(res[i + 1].FirstValue);
                }

                else
                {
                    ires.Add(res[i].FirstValue);
                    ires.Add(res[i + 1].FirstValue);
                }

                backNum = i + 1;
            }

            return ires;
        }

        /// <summary>現在のY位置でのX座標を非ゼロ回転数規則アルゴリズムに則って返す(傾き情報も含めて：FirstValueにX座標、SecondValueに傾きが入っている)</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public System.Collections.Generic.List<PluralsValue<int, int>> RollNowLineAA(int Y)
        {
            Collections.Generic.List<PluralsValue<int, bool,int>> res = new System.Collections.Generic.List<PluralsValue<int, bool,int>>();
            Collections.Generic.List<PluralsValue<int, int>> ires = new System.Collections.Generic.List<PluralsValue<int, int>>();

            int cnt;
            int backNum = -1;

            for (int i = 0; i < this.SideList.Count; i++)
            {
                if (this.SideList[i].IsCalcY(Y))
                {
                    if (this.SideList[i].AddX == int.MaxValue)
                    {
                        res.Add(new PluralsValue<int, bool, int>(this.SideList[i].X, this.SideList[i].IsUpperSide, 0));
                        res.Add(new PluralsValue<int, bool, int>(this.SideList[i].End.X, this.SideList[i].IsUpperSide, 0));
                    }

                    else
                        res.Add(new PluralsValue<int, bool, int>(this.SideList[i].X, this.SideList[i].IsUpperSide, this.SideList[i].AddX));
                }
            }

            res.Sort();

            for (int i = 0; i < res.Count - 1; i++)
            {
                cnt = 0;

                for (int j = 0; j <= i; j++)
                {
                    if (res[j].SecondValue) cnt++;
                    else cnt--;
                }

                if (cnt == 0)
                    continue;

                if (i == backNum)
                {
                    ires.RemoveAt(ires.Count - 1);
                    ires.Add(new PluralsValue<int, int>(res[i + 1].FirstValue, res[i + 1].ThirdValue));
                }

                else
                {
                    ires.Add(new PluralsValue<int, int>(res[i].FirstValue, res[i].ThirdValue));
                    ires.Add(new PluralsValue<int, int>(res[i + 1].FirstValue, res[i + 1].ThirdValue));
                }

                backNum = i + 1;
            }

            return ires;
        }
    }
    #endregion

    #region FixLineImageCalcクラス
    /// <summary>FixLineImageCalcクラス</summary>
    internal class FixLineImageCalc
    {
        /// <summary>計算に使用する辺のリスト</summary>
        private FixLine[,] SideList;

        /// <summary>コンストラクタ</summary>
        /// <param name="SideList">辺情報の配列、[0,*]:Dest、[1,*];Src</param>
        /// <exception cref="System.ArgumentOutOfRangeException">SideListの配列の種類が FixLine[2,4] と違う場合に発生</exception>
        public FixLineImageCalc(FixLine[,] SideList)
        {
            if (SideList.Length != 8 || SideList.GetLength(0) != 2 || SideList.GetLength(1) != 4) throw new ArgumentOutOfRangeException("SideList", "SideListの配列の種類が FixLine[2,4] と違います。");

            for (int i = 0; i < 4; i++)
            {
                SideList[1, i].CompareStart = SideList[0, i].Start;
                SideList[1, i].CompareEnd = SideList[0, i].End;

                if (SideList[1, i].AddX == int.MaxValue)
                {
                    SideList[1, i].AddX = (SideList[0, i].End.Y != SideList[0, i].Start.Y ? (SideList[1, i].End.X - SideList[1, i].Start.X) / (SideList[0, i].End.Y - SideList[0, i].Start.Y) : 0);
                    SideList[1, i].AddY = 0;
                }

                else
                {
                    SideList[1, i].AddY = (SideList[0, i].End.Y != SideList[0, i].Start.Y ? (SideList[1, i].End.Y - SideList[1, i].Start.Y) / (SideList[0, i].End.Y - SideList[0, i].Start.Y) : 0);
                    SideList[1, i].AddX = 0;
                }

                //辺の始点・終点を反転したのと反転していない辺では描画時に一致しなくなるのでSrcの方を反転
                if (SideList[0, i].ReverseValue != SideList[1,i].ReverseValue)
                {
                    SideList[1, i].AddX = -SideList[1, i].AddX;
                    SideList[1, i].AddY = -SideList[1, i].AddY;

                    SideList[1, i].X = SideList[1, i].End.X;
                    SideList[1, i].Y = SideList[1, i].End.Y;
                }
            }

            this.SideList = SideList;
        }

        /// <summary>現在のY位置でのDestX座標とSrcのX,Y座標を返す(FirstValueにDestX座標、SecondValueにSrc座標)</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public PluralsValue<int, iPoint>[] NowLine(int Y)
        {
            Collections.Generic.List<PluralsValue<int, iPoint>> res = new System.Collections.Generic.List<PluralsValue<int, iPoint>>();

            for (int i = 0; i < this.SideList.GetLength(1); i++)
            {
                if (this.SideList[0, i].IsCalcY(Y) && this.SideList[1, i].IsCalcYBoth(Y))
                {
                    res.Add(new PluralsValue<int, iPoint>(this.SideList[0, i].X, this.SideList[1, i].Point));

                    if (this.SideList[0,i].AddX == int.MaxValue)
                        res.Add(new PluralsValue<int, iPoint>(this.SideList[0, i].End.X, this.SideList[1, i].End));
                }
            }

            res.Sort();

            return res.ToArray();
        }

        /// <summary>現在のY位置でのX座標を全て返す(傾き情報も含めて：FirstValueにDestX座標、SecondValueに傾き、ThirdValueにSrc座標が入っている)</summary>
        /// <param name="Y">現在のY座標</param>
        /// <returns>取得したX座標配列(固定小数)</returns>
        public PluralsValue<int, int, iPoint>[] NowLineAA(int Y)
        {
            Collections.Generic.List<PluralsValue<int, int, iPoint>> res = new System.Collections.Generic.List<PluralsValue<int, int, iPoint>>();

            for (int i = 0; i < this.SideList.GetLength(1); i++)
            {
                if (this.SideList[0, i].IsCalcY(Y) && this.SideList[1, i].IsCalcYBoth(Y))
                {
                    if (this.SideList[0, i].AddX == int.MaxValue)
                    {
                        res.Add(new PluralsValue<int, int, iPoint>(this.SideList[0, i].X, 0, this.SideList[1, i].Point));
                        res.Add(new PluralsValue<int, int, iPoint>(this.SideList[0, i].End.X, 0, this.SideList[1, i].End));
                    }

                    else
                        res.Add(new PluralsValue<int, int, iPoint>(this.SideList[0, i].X, this.SideList[0, i].AddX, this.SideList[1, i].Point));
                }
            }

            res.Sort();

            return res.ToArray();
        }
    }
    #endregion

    #region Bezierクラス
    /// <summary>ベジエ曲線のパラメータの保有および計算をするクラス</summary>
    internal class Bezier
    {
        private double[] Param;

        /// <summary>ベジエ曲線のパラメータを取得する</summary>
        public double[] Parameter
        {
            get { return this.Param; }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="P0">始点</param>
        /// <param name="P1">制御点1</param>
        /// <param name="P2">制御点2</param>
        /// <param name="P3">終点</param>
        public Bezier(double P0, double P1, double P2, double P3)
        {
            this.Param = new double[4] { P0, P1, P2, P3 };
        }

        /// <summary>ベジエクラスをX、Yの二次元座標で作成する</summary>
        /// <param name="X">作成したX座標用のベジエクラスを入力する変数</param>
        /// <param name="Y">作成したY座標用のベジエクラスを入力する変数</param>
        /// <param name="P0">始点</param>
        /// <param name="P1">制御点1</param>
        /// <param name="P2">制御点2</param>
        /// <param name="P3">終点</param>
        public static void GetBezier(out Bezier X, out Bezier Y, Point P0, Point P1, Point P2, Point P3)
        {
            X = new Bezier(P0.X, P1.X, P2.X, P3.X);
            Y = new Bezier(P0.Y, P1.Y, P2.Y, P3.Y);
        }

        /// <summary>補間位置を取得する</summary>
        /// <param name="t">現在位置 0.0&lt;=t&lt;=1.0</param>
        /// <returns>取得した補間位置</returns>
        public double GetPosition(double t)
        {
            double u = 1.0-t;

            return u * u * u * this.Param[0]
                 + 3 * t * u * u * this.Param[1]
                 + 3 * t * t * u * this.Param[2]
                 + t * t * t * this.Param[3];
        }

        /// <summary>ベジエ曲線に使う長さを取得する</summary>
        /// <param name="X">X座標用のベジエクラス</param>
        /// <param name="Y">Y座標用のベジエクラス</param>
        /// <param name="Divide">近似したい直線に分割する数</param>
        /// <returns>分割した時の長さ</returns>
        public static double GetBezierLength(Bezier X, Bezier Y, int Divide)
        {
            double length = 0.0;
            double t = 0.0;
            double dt = 1.0 / Divide;
            double X0, Y0, X1, Y1;
            double len;
            double X01,Y01;

            X1 = X.GetPosition(t);
            Y1 = Y.GetPosition(t);
            t += dt;

            for (int i = 0; i < Divide; i++)
            {
                X0 = X1;
                Y0 = Y1;
                X1 = X.GetPosition(t);
                Y1 = Y.GetPosition(t);

                X01 = X1 - X0;
                Y01 = Y1 - Y0;

                len = X01 * X01 + Y01 * Y01;
                if (len != 0.0) length += Math.Sqrt(len);

                t += dt;
            }

            return length;
        }

        /// <summary>指定したベジエ曲線を形作るPoint配列から多角形のPoint配列に変換する</summary>
        /// <param name="Points">ベジエ曲線の始点、制御点2つ、終点の連続したPoint配列(6点以上の3n点のPoint配列)</param>
        /// <param name="R">近似する直線の長さ</param>
        /// <returns>作成した多角形を形作るPoint配列</returns>
        public static Point[] CreatePolygon(Point[] Points, double R)
        {
            Collections.Generic.List<Point> res = new System.Collections.Generic.List<Point>();
            Bezier[,] Beziers = new Bezier[2, Points.Length / 3];

            for (int i = 0; i < Beziers.GetLength(1); i++)
            {
                Beziers[0, i] = new Bezier(Points[i * 3].X, Points[i * 3 + 1].X, Points[i * 3 + 2].X, Points[(i * 3 + 3).ReverseMaxClipping(0, Points.Length - 1)].X);
                Beziers[1, i] = new Bezier(Points[i * 3].Y, Points[i * 3 + 1].Y, Points[i * 3 + 2].Y, Points[(i * 3 + 3).ReverseMaxClipping(0, Points.Length - 1)].Y);
            }

            for (int i = 0; i < Beziers.GetLength(1); i++)
            {
                Bezier X = Beziers[0, i];
                Bezier Y = Beziers[1, i];

                double length = Bezier.GetBezierLength(X, Y, 8);
                if (length == 0) continue;

                double delta = R / length;

                double t = 0.0;

                while (t < 1.0)
                {
                    double x = X.GetPosition(t);
                    double y = Y.GetPosition(t);

                    res.Add(new Point(x, y));
                    t += delta;
                }
            }

            return res.ToArray();
        }
    }
    #endregion

    #endregion

    #region CustomWriteableBitmapクラス
    /// <summary>WriteableBitmapに高速アクセスにするラッパークラス</summary>
    /// <remarks>注意
    /// <para>このクラスはアクセス速度を向上する代わりに作成コスト・メモリコストを犠牲にします。</para>
    /// <para>従ってこのクラスを使う時に作成しては速度の向上は望めません。</para>
    /// <para>使用するときはあらかじめ作成しておく事をお勧めします。</para>
    /// <para>描画範囲を指定して作成した場合、その範囲外でWriteableBitmapのイメージサイズ内でのアクセスは全て 0, 0 にアクセスすることになります。</para>
    /// <example><para><code>CustomWriteableBitmap bmp = new CustomWriteableBitmap(img); //imgはWriteableBitmap</code></para>
    /// <para><code>CustomWriteableBitmap bmp = new CustomWriteableBitmap(img, imgRect); //imgRectはiRect</code></para></example></remarks>
    public class CustomWriteableBitmap
    {
        #region フィールド・プロパティ・その他のメソッド
        private WriteableBitmap Target;
        private int PColor;

        /// <summary>描画限界サイズ</summary>
        private readonly iSize LimitSize;

        /// <summary>描画可能範囲</summary>
        private readonly iRect Rect;

        /// <summary>Index[Y,X]</summary>
        private readonly int[,] Index;

        /// <summary>指定した場所のピクセルを取得または設定する</summary>
        /// <param name="Index">ピクセルのメモリ位置(1次元配列の位置)</param>
        /// <returns>取得したピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の時に発生</exception>
        public int this[int Index]
        {
            get { return this.Target.Pixels[Index]; }
            set { this.Target.Pixels[Index] = value; }
        }

        /// <summary>指定した場所のピクセルを取得または設定する</summary>
        /// <param name="X">ピクセルのX座標(Left &lt;= X &lt; Right)</param>
        /// <param name="Y">ピクセルのY座標(Top &lt;= X &lt; Bottom)</param>
        /// <returns>取得したピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public int this[int X, int Y]
        {
            get { return this.Target.Pixels[this.Index[Y, X]]; }
            set { this.Target.Pixels[this.Index[Y, X]] = value; }
        }

        /// <summary>現在読み書きしているWriteableBitmapのピクセル配列を取得する</summary>
        public int[] Pixels
        {
            get { return this.Target.Pixels; }
        }

        /// <summary>現在読み書きしているWriteableBitmapの幅を取得する</summary>
        public int PixelWidth
        {
            get { return this.LimitSize.Width; }
        }

        /// <summary>現在読み書きしているWriteableBitmapの高さを取得する</summary>
        public int PixelHeight
        {
            get { return this.LimitSize.Height; }
        }

        /// <summary>現在読み書きしているWriteableBitmapのサイズを取得する</summary>
        public iSize PixelSize
        {
            get { return this.LimitSize; }
        }

        /// <summary>現在読み書きしているWriteableBitmapを取得する</summary>
        public WriteableBitmap Value
        {
            get { return this.Target; }
        }

        /// <summary>ラスターオペレーションで使うパターン色を取得または設定する</summary>
        public Color PatternColor
        {
            get { return this.PColor.ToColor(); }
            set { this.PColor = value.ToArgb(); }
        }

        /// <summary>オブジェクトを複製して返す</summary>
        /// <returns>複製したオブジェクト</returns>
        public CustomWriteableBitmap Clone()
        {
            return new CustomWriteableBitmap(new WriteableBitmap(this.Target), (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>コピーのためのコンストラクタ</summary>
        /// <param name="Image">対象のイメージ</param>
        /// <param name="Index">内部で使うIndex</param>
        /// <param name="Rect">内部で使うiRect</param>
        /// <param name="PColor">パターンカラー</param>
        /// <exception cref="System.ArgumentNullException">Image、Indexのどちらかがnullの場合に発生</exception>
        private CustomWriteableBitmap(WriteableBitmap Image, int[,] Index, iRect Rect, int PColor)
        {
            if (Image == null) throw new ArgumentNullException("Image", "Imageがnull参照です。");
            if (Index == null) throw new ArgumentNullException("Index", "Indexがnull参照です。");

            this.Target = Image;
            this.PColor = PColor;
            this.Rect = Rect;
            this.Index = Index;
            this.LimitSize = new iSize(this.Target.PixelWidth, this.Target.PixelHeight);
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Image">対象のイメージ</param>
        /// <exception cref="System.ArgumentNullException">Imageがnullの場合に発生</exception>
        public CustomWriteableBitmap(WriteableBitmap Image)
        {
            if (Image == null) throw new ArgumentNullException("Image", "Imageがnull参照です。");

            this.Target = Image;
            this.LimitSize = new iSize(this.Target.PixelWidth, this.Target.PixelHeight);
            this.PColor = 0;
            this.Rect = new iRect(0, 0, this.LimitSize.Width, this.LimitSize.Height);
            this.Index = new int[this.LimitSize.Height, this.LimitSize.Width];
            int cnt = 0;

            for (int Y = 0; Y != this.LimitSize.Height; Y++)
            {
                for (int X = 0; X != this.LimitSize.Width; X++)
                {
                    this.Index[Y, X] = cnt;
                    cnt++;
                }
            }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Image">対象のイメージ</param>
        /// <param name="Rect">描画に使う範囲</param>
        /// <exception cref="System.ArgumentNullException">Imageがnullの場合に発生</exception>
        public CustomWriteableBitmap(WriteableBitmap Image, iRect Rect)
        {
            if (Image == null) throw new ArgumentNullException("Image", "Imageがnull参照です。");

            this.Target = Image;
            this.LimitSize = new iSize(this.Target.PixelWidth, this.Target.PixelHeight);
            this.PColor = 0;
            this.Rect = Rect;

            if (this.Rect.X < 0) this.Rect.X = 0;
            if (this.Rect.Y < 0) this.Rect.Y = 0;
            if (this.Rect.Width > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width;
            if (this.Rect.Height > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height;
            if (this.Rect.Right > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width - this.Rect.X;
            if (this.Rect.Bottom > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height - this.Rect.Y;

            this.Index = new int[this.LimitSize.Height, this.LimitSize.Width];
            int cnt = this.Rect.Top * this.LimitSize.Width + this.Rect.Left;
            int Left;
            int Right = this.Rect.Right;
            int Top = this.Rect.Top;
            int Bottom = this.Rect.Bottom;
            int dWidth = this.LimitSize.Width - this.Rect.Width;

            while (Top != Bottom)
            {
                for (Left = this.Rect.Left; Left != Right; Left++)
                {
                    this.Index[Top, Left] = cnt;
                    cnt++;
                }

                cnt += dWidth;

                Top++;
            }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Image">対象のイメージ</param>
        /// <param name="Point">描画に使う範囲の最小値</param>
        /// <param name="Size">描画に使うサイズ</param>
        /// <exception cref="System.ArgumentNullException">Imageがnullの場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">SizeのWidthまたはHeightが0の場合に発生する</exception>
        public CustomWriteableBitmap(WriteableBitmap Image, iPoint Point, iSize Size)
        {
            if (Image == null) throw new ArgumentNullException("Image", "Imageがnull参照です。");

            if (Size.Width == 0 || Size.Height == 0)
                throw new ArgumentOutOfRangeException("Width , Height", "指定したサイズのWidthまたはHeightが0です。");

            this.Target = Image;
            this.LimitSize = new iSize(this.Target.PixelWidth, this.Target.PixelHeight);
            this.PColor = 0;
            this.Rect = new iRect(Point, Size);

            if (this.Rect.X < 0) this.Rect.X = 0;
            if (this.Rect.Y < 0) this.Rect.Y = 0;
            if (this.Rect.Width > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width;
            if (this.Rect.Height > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height;
            if (this.Rect.Right > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width - this.Rect.X;
            if (this.Rect.Bottom > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height - this.Rect.Y;

            this.Index = new int[this.LimitSize.Height, this.LimitSize.Width];
            int cnt = this.Rect.Top * this.LimitSize.Width + this.Rect.Left;
            int Left;
            int Right = this.Rect.Right;
            int Top = this.Rect.Top;
            int Bottom = this.Rect.Bottom;
            int dWidth = this.LimitSize.Width - this.Rect.Width;

            while (Top != Bottom)
            {
                for (Left = this.Rect.Left; Left != Right; Left++)
                {
                    this.Index[Top, Left] = cnt;
                    cnt++;
                }

                cnt += dWidth;

                Top++;
            }
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Image">対象のイメージ</param>
        /// <param name="Left">描画に使うX軸の最小値</param>
        /// <param name="Top">描画に使うY軸の最小値</param>
        /// <param name="Width">描画に使う幅</param>
        /// <param name="Height">描画に使う高さ</param>
        /// <exception cref="System.ArgumentNullException">Imageがnullの場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">WidthとHeightのいずれかが0以下だった場合に発生する</exception>
        public CustomWriteableBitmap(WriteableBitmap Image, int Left, int Top, int Width, int Height)
        {
            if (Image == null) throw new ArgumentNullException("Image", "Imageがnull参照です。");

            if (Width <= 0 || Height <= 0)
                throw new ArgumentOutOfRangeException("Width , Height", "WidthとHeightはプラスの値でなければなりません。");

            this.Target = Image;
            this.LimitSize = new iSize(this.Target.PixelWidth, this.Target.PixelHeight);
            this.PColor = 0;
            this.Rect = new iRect(Left, Top, Width, Height);

            if (this.Rect.X < 0) this.Rect.X = 0;
            if (this.Rect.Y < 0) this.Rect.Y = 0;
            if (this.Rect.Width > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width;
            if (this.Rect.Height > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height;
            if (this.Rect.Right > this.LimitSize.Width) this.Rect.Width = this.LimitSize.Width - this.Rect.X;
            if (this.Rect.Bottom > this.LimitSize.Height) this.Rect.Height = this.LimitSize.Height - this.Rect.Y;

            this.Index = new int[this.LimitSize.Height, this.LimitSize.Width];
            int cnt = this.Rect.Top * this.LimitSize.Width + this.Rect.Left;
            int Right = this.Rect.Right;
            int Bottom = this.Rect.Bottom;
            int dWidth = this.LimitSize.Width - this.Rect.Width;

            Top = this.Rect.Top;

            while (Top != Bottom)
            {
                for (Left = this.Rect.Left; Left != Right; Left++)
                {
                    this.Index[Top, Left] = cnt;
                    cnt++;
                }

                cnt += dWidth;

                Top++;
            }
        }

        /// <summary>System.Windows.DependencyObject から依存関係プロパティの現在の有効値を返す</summary>
        /// <param name="dp">値を取得する対象のプロパティの System.Windows.DependencyProperty 識別子</param>
        /// <returns>現在の有効値を返す</returns>
        /// <exception cref="System.ArgumentNullException">dp が null です</exception>
        public object GetValue(DependencyProperty dp)
        {
            return this.Target.GetValue(dp);
        }

        /// <summary>System.Windows.DependencyObject で依存関係プロパティのローカル値を設定する</summary>
        /// <param name="dp">設定する依存関係プロパティの識別子</param>
        /// <param name="value">新しいローカル値</param>
        /// <exception cref="System.ArgumentNullException">dp が null です</exception>
        public void SetValue(DependencyProperty dp, object value)
        {
            this.Target.SetValue(dp, value);
        }

        /// <summary>ローカル値が設定されている場合、依存関係プロパティのローカル値を返す</summary>
        /// <param name="dp">ローカル値を取得する対象のプロパティの System.Windows.DependencyProperty 識別子</param>
        /// <returns>ローカル値を返します。ローカル値が設定されていない場合は sentinel 値 System.Windows.DependencyProperty.UnsetValue を返す</returns>
        /// <exception cref="System.ArgumentNullException">dp が null です</exception>
        public object ReadLocalValue(DependencyProperty dp)
        {
            return this.Target.ReadLocalValue(dp);
        }

        /// <summary>ビットマップ全体の描画を要求する</summary>
        [System.Security.SecuritySafeCritical]
        public void Invalidate()
        {
            this.Target.Invalidate();
        }

        /// <summary>ビットマップ内の要素をレンダリングする</summary>
        /// <param name="element">ビットマップ内にレンダリングされる要素</param>
        /// <param name="transform">ビットマップへの描画前に要素に適用する変換 空の変換を指定した場合、その要素を表すビットが、親内に配置されているかのように同じオフセット位置に表示される</param>
        [System.Security.SecuritySafeCritical]
        public void Render(UIElement element, Transform transform)
        {
            this.Target.Render(element, transform);
        }

        /// <summary>CustomWriteableBitmapをWriteableBitmapに明示的に変換する</summary>
        /// <param name="Obj">対象のCustomWriteableBitmap</param>
        /// <returns>変換後のWriteableBitmap</returns>
        public static explicit operator WriteableBitmap(CustomWriteableBitmap Obj)
        {
            return Obj.Target;
        }

        /// <summary>指定した色を透明色にする(不可逆変換)</summary>
        /// <param name="TransparentColor">透明色に変える色</param>
        public void MakeTransparent(Color TransparentColor)
        {
            int TC = TransparentColor.ToArgb();

            for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
            {
                for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                {
                    if (this.Target.Pixels[this.Index[i, j]] == TC)
                        this.Target.Pixels[this.Index[i, j]] = 0;
                }
            }
        }

        /// <summary>指定した色を別の色にする(不可逆変換)</summary>
        /// <param name="ChangeColor">別の色に変える指定色</param>
        /// <param name="MakeColor">変えた後の指定色</param>
        public void MakeColor(Color ChangeColor, Color MakeColor)
        {
            int TC = ChangeColor.ToArgb();
            int MC = MakeColor.ToArgb();

            for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
            {
                for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                {
                    if (this.Target.Pixels[this.Index[i, j]] == TC)
                        this.Target.Pixels[this.Index[i, j]] = MC;
                }
            }
        }

        /// <summary>全てのピクセルに対して不透明度を割合的に設定する(不可逆変換)</summary>
        /// <param name="Ratio">不透明度の割合(255でそのまま0で全てを透明)</param>
        public void MakeRatioOpacity(byte Ratio)
        {
            if (Ratio != 0xFF)
            {
                for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
                {
                    for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                        this.Target.Pixels[this.Index[i, j]] = this.Target.Pixels[this.Index[i, j]].NewBlendArgb(Ratio);
                }
            }
        }

        /// <summary>全てのピクセルに対して各要素を割合的に設定する(不可逆変換)</summary>
        /// <param name="Ratio">各要素の割合(255でそのまま0で全てを透明)</param>
        public void MakeRatioPixelElements(byte Ratio)
        {
            if (Ratio != 0xFF)
            {
                for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
                {
                    for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                        this.Target.Pixels[this.Index[i, j]] = this.Target.Pixels[this.Index[i, j]].NewBlendArgb(Ratio).CalcAlphaBlendToArgb();
                }
            }
        }
        #endregion

        #region ピクセル操作

        #region メモリ参照
        /// <summary>指定した場所のピクセルを取得する</summary>
        /// <param name="Index">取得するピクセルのメモリ位置</param>
        /// <returns>指定されたピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public int GetPixel(int Index)
        {
            return this.Target.Pixels[Index];
        }

        /// <summary>指定した場所のピクセルを設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixel(int Index, int Color)
        {
            this.Target.Pixels[Index] = Color;
        }

        /// <summary>指定した場所のピクセルをα値を指定して設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixel(int Index, int Color, byte Alpha)
        {
            this.Target.Pixels[Index] = Color.NewArgb(Alpha);
        }

        /// <summary>指定した場所のピクセルを背景色を無色と仮定して設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixelBlendCopy(int Index, int Color)
        {
            this.Target.Pixels[Index] = Color.AlphaBlend();
        }

        /// <summary>指定した場所のピクセルを背景色を無色と仮定してα値を指定して設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixelBlendCopy(int Index, int Color, byte Alpha)
        {
            this.Target.Pixels[Index] = Color.AlphaBlend(Alpha);
        }

        /// <summary>指定した場所のピクセルをαブレンドして設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixelBlend(int Index, int Color)
        {
            this.Target.Pixels[Index] = this.Target.Pixels[Index].AlphaBlend(Color);
        }

        /// <summary>指定した場所のピクセルをα値を指定してαブレンドして設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixelBlend(int Index, int Color, byte Alpha)
        {
            this.Target.Pixels[Index] = this.Target.Pixels[Index].AlphaBlend(Color, Alpha);
        }

        /// <summary>指定した場所のピクセルをクイックαブレンドして設定する</summary>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルのバイト配列色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">Indexが範囲外の場合に発生</exception>
        public void SetPixelQBlend(int Index, byte[] Color)
        {
            this.Target.Pixels[Index] = this.Target.Pixels[Index].QuickAlphaBlend(Color);
        }
        #endregion

        #region 座標参照
        /// <summary>指定した場所のピクセルを取得する</summary>
        /// <param name="X">取得するピクセルのX座標</param>
        /// <param name="Y">取得するピクセルのY座標</param>
        /// <returns>指定されたピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public int GetPixel(int X, int Y)
        {
            return this.Target.Pixels[this.Index[Y, X]];
        }

        /// <summary>固定小数で指定した場所のピクセルをAntiAliasを考慮して取得する</summary>
        /// <param name="FixX">取得するピクセルのX座標</param>
        /// <param name="FixY">取得するピクセルのY座標</param>
        /// <returns>指定されたピクセルの色情報(ARGB形式)</returns>
        /// <exception cref="System.IndexOutOfRangeException">FixXかFixYがイメージの範囲外の時に発生</exception>
        public int GetPixelAA(int FixX, int FixY)
        {
            byte fx = FixX.fPartToByte();
            byte fy = FixY.fPartToByte();
            int iX = FixX.iPart();
            int iY = FixY.iPart();

            byte[] Pixel = new byte[4];
            Pixel[0] = (byte)(fx.Not() * fy.Not() >> 8);
            Pixel[1] = (byte)(fx * fy.Not() >> 8);
            Pixel[2] = (byte)(fx.Not() * fy >> 8);
            Pixel[3] = (byte)(fx * fy >> 8);

            int A = 0, R = 0, G = 0, B = 0;
            int sx, sy;
            byte[] ARGB = default(byte[]);

            for (int i = 0; i < 4; i++)
            {
                sx = (iX + (i & 0x1));
                sy = (iY + (i & 0x2));

                if (sx >= this.Rect.Right || sy >= this.Rect.Bottom)
                    ARGB = new byte[4] { 0, 0, 0, 0 };

                else
                    ARGB = this.Target.Pixels[this.Index[sy, sx]].ToBytes();

                A += ARGB[0] * Pixel[i];
                R += ARGB[1] * Pixel[i];
                G += ARGB[2] * Pixel[i];
                B += ARGB[3] * Pixel[i];
            }

            ARGB[0] = (byte)(A >> 8);
            ARGB[1] = (byte)(R >> 8);
            ARGB[2] = (byte)(G >> 8);
            ARGB[3] = (byte)(B >> 8);

            return ARGB.ToArgb();
        }

        /// <summary>指定した場所のピクセルを設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixel(int X, int Y, int Color)
        {
            this.Target.Pixels[this.Index[Y, X]] = Color;
        }

        /// <summary>指定した場所のピクセルをα値を指定して設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixel(int X, int Y, int Color, byte Alpha)
        {
            this.Target.Pixels[this.Index[Y, X]] = Color.NewArgb(Alpha);
        }

        /// <summary>指定した場所のピクセルを背景色を無色と仮定して設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixelBlendCopy(int X, int Y, int Color)
        {
            this.Target.Pixels[this.Index[Y, X]] = Color.AlphaBlend();
        }

        /// <summary>指定した場所のピクセルを背景色を無色と仮定してα値を指定して設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixelBlendCopy(int X, int Y, int Color, byte Alpha)
        {
            this.Target.Pixels[this.Index[Y, X]] = Color.AlphaBlend(Alpha);
        }

        /// <summary>指定した場所のピクセルをαブレンドして設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixelBlend(int X, int Y, int Color)
        {
            this.Target.Pixels[this.Index[Y, X]] = this.Target.Pixels[this.Index[Y, X]].AlphaBlend(Color);
        }

        /// <summary>指定した場所のピクセルをα値を指定してαブレンドして設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <param name="Alpha">新しく設定するα値</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixelBlend(int X, int Y, int Color, byte Alpha)
        {
            this.Target.Pixels[this.Index[Y, X]] = this.Target.Pixels[this.Index[Y, X]].AlphaBlend(Color, Alpha);
        }

        /// <summary>指定した場所のピクセルをクイックαブレンドして設定する</summary>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルのバイト配列色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">XかYがイメージの範囲外の時に発生</exception>
        public void SetPixelQBlend(int X, int Y, byte[] Color)
        {
            this.Target.Pixels[this.Index[Y, X]] = this.Target.Pixels[this.Index[Y, X]].QuickAlphaBlend(Color);
        }

        /// <summary>固定小数で指定した場所のピクセルをAntiAliasを考慮して設定する</summary>
        /// <param name="FixX">設定するピクセルのX座標</param>
        /// <param name="FixY">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">FixXかFixYがイメージの範囲外の時に発生</exception>
        public void SetPixelAA(int FixX, int FixY, int Color)
        {
            byte fx = FixX.fPartToByte();
            byte fy = FixY.fPartToByte();
            int iX = FixX.iPart();
            int iY = FixY.iPart();

            byte f0, f1, f2, f3;
            f0 = (byte)(fx.Not() * fy.Not() >> 8);
            f1 = (byte)(fx * fy.Not() >> 8);
            f2 = (byte)(fx.Not() * fy >> 8);
            f3 = (byte)(fx * fy >> 8);

            this.Target.Pixels[this.Index[iY, iX]] = Color.NewArgb(f0);

            if (iX + 1 < this.Rect.Right)
            {
                this.Target.Pixels[this.Index[iY, iX + 1]] = Color.NewArgb(f1);

                if (iY + 1 < this.Rect.Bottom)
                {
                    this.Target.Pixels[this.Index[iY + 1, iX]] = Color.NewArgb(f2);
                    this.Target.Pixels[this.Index[iY + 1, iX + 1]] = Color.NewArgb(f3);
                }
            }

            else if (iY + 1 < this.Rect.Bottom)
                this.Target.Pixels[this.Index[iY + 1, iX]] = Color.NewArgb(f2);
        }

        /// <summary>固定小数で指定した場所のピクセルをAntiAliasを考慮してαブレンド設定する</summary>
        /// <param name="FixX">設定するピクセルのX座標</param>
        /// <param name="FixY">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルの色情報(ARGB形式)</param>
        /// <exception cref="System.IndexOutOfRangeException">FixXかFixYがイメージの範囲外の時に発生</exception>
        public void SetPixelBlendAA(int FixX, int FixY, int Color)
        {
            byte fx = FixX.fPartToByte();
            byte fy = FixY.fPartToByte();
            int iX = FixX.iPart();
            int iY = FixY.iPart();

            byte f0, f1, f2, f3;
            f0 = (byte)(fx.Not() * fy.Not() >> 8);
            f1 = (byte)(fx * fy.Not() >> 8);
            f2 = (byte)(fx.Not() * fy >> 8);
            f3 = (byte)(fx * fy >> 8);

            this.Target.Pixels[this.Index[iY, iX]] = this.Target.Pixels[this.Index[iY, iX]].AlphaBlend(Color, f0);

            if (iX + 1 < this.Rect.Right)
            {
                this.Target.Pixels[this.Index[iY, iX + 1]] = this.Target.Pixels[this.Index[iY, iX + 1]].AlphaBlend(Color, f1);

                if (iY + 1 < this.Rect.Bottom)
                {
                    this.Target.Pixels[this.Index[iY + 1, iX]] = this.Target.Pixels[this.Index[iY + 1, iX]].AlphaBlend(Color, f2);
                    this.Target.Pixels[this.Index[iY + 1, iX + 1]] = this.Target.Pixels[this.Index[iY + 1, iX + 1]].AlphaBlend(Color, f3);
                }
            }

            else if (iY + 1 < this.Rect.Bottom)
                this.Target.Pixels[this.Index[iY + 1, iX]] = this.Target.Pixels[this.Index[iY + 1, iX]].AlphaBlend(Color, f2);
        }
        #endregion

        #endregion

        #region Penを使った線の描画

        #region CreateLines
        /// <summary>線作成のためのクラス</summary>
        private class CreateLines
        {
            private Point CP;
            private Pen Pen;
            private Func<Point, Point, double> func;

            /// <summary>コンストラクタ</summary>
            /// <param name="DrawPen">描画するペン</param>
            public CreateLines(Pen DrawPen)
            {
                this.Pen = DrawPen;
            }

            #region CreatePoints
            /// <summary>Penを使うメソッドの長方形のサイズを計算して作成する</summary>
            /// <param name="Width">作成する際のペンの太さ</param>
            /// <param name="StartX">始点X</param>
            /// <param name="StartY">始点Y</param>
            /// <param name="EndX">終点X</param>
            /// <param name="EndY">終点Y</param>
            /// <param name="iP">生成した4点のiPoint配列を代入する配列</param>
            /// <returns>作成した4点のPoint配列</returns>
            public static Point[] CreatePoints(double Width, double StartX, double StartY, double EndX, double EndY, out iPoint[] iP)
            {
                double r = Width / 2.0;

                double dx;
                double dy;

                if (EndY != StartY)
                {
                    double deltaR = -((EndX - StartX) / (EndY - StartY));
                    double theta = Math.Atan(deltaR);
                    dx = (Math.Cos(theta) * r);//.AbsCeiling();
                    dy = (Math.Sin(theta) * r);//.AbsCeiling();
                }

                else
                {
                    dx = 0;
                    dy = r;
                }

                double TLX = StartX - dx;
                double TRX = StartX + dx;

                double TTY = StartY - dy;
                double TBY = StartY + dy;

                double BLX = EndX - dx;
                double BRX = EndX + dx;

                double BTY = EndY - dy;
                double BBY = EndY + dy;

                iP = new iPoint[4] { new iPoint((int)TLX, (int)TTY), new iPoint((int)BLX, (int)BTY), new iPoint((int)TRX, (int)TBY), new iPoint((int)BRX, (int)BBY) };

                return new Point[4] { new Point(TLX, TTY), new Point(BLX, BTY), new Point(TRX, TBY), new Point(BRX, BBY) };
            }

            /// <summary>Penを使うメソッドの長方形のサイズを計算して作成する</summary>
            /// <param name="Width">作成する際のペンの太さ</param>
            /// <param name="Start">始点</param>
            /// <param name="End">終点</param>
            /// <param name="iP">生成した4点のiPoint配列を代入する配列</param>
            /// <returns>作成した4点のPoint配列</returns>
            public static Point[] CreatePoints(double Width, Point Start, Point End, out iPoint[] iP)
            {
                double r = Width / 2.0;

                double dx;
                double dy;

                if (End.Y != Start.Y)
                {
                    double deltaR = -((End.X - Start.X) / (End.Y - Start.Y));
                    double theta = Math.Atan(deltaR);
                    dx = (Math.Cos(theta) * r);//.AbsCeiling();
                    dy = (Math.Sin(theta) * r);//.AbsCeiling();
                }

                else
                {
                    dx = 0;
                    dy = r;
                }

                double TLX = Start.X - dx;
                double TRX = Start.X + dx;

                double TTY = Start.Y - dy;
                double TBY = Start.Y + dy;

                double BLX = End.X - dx;
                double BRX = End.X + dx;

                double BTY = End.Y - dy;
                double BBY = End.Y + dy;

                iP = new iPoint[4] { new iPoint((int)TLX, (int)TTY), new iPoint((int)BLX, (int)BTY), new iPoint((int)TRX, (int)TBY), new iPoint((int)BRX, (int)BBY) };

                return new Point[4] { new Point(TLX, TTY), new Point(BLX, BTY), new Point(TRX, TBY), new Point(BRX, BBY) };
            }

            /// <summary>Penを使うメソッドの長方形のサイズを計算して作成する</summary>
            /// <param name="Start">始点</param>
            /// <param name="End">終点</param>
            /// <returns>作成した4点のPoint配列</returns>
            private Point[] CreatePoints(Point Start, Point End)
            {
                double r = this.Pen.Width / 2.0;

                double dx;
                double dy;

                if (End.Y != Start.Y)
                {
                    double deltaR = -((End.X - Start.X) / (End.Y - Start.Y));
                    double theta = Math.Atan(deltaR);
                    dx = (Math.Cos(theta) * r).AbsCeiling();
                    dy = (Math.Sin(theta) * r).AbsCeiling();
                }

                else
                {
                    dx = 0;
                    dy = r;
                }

                double TLX = Start.X - dx;
                double TRX = Start.X + dx;

                double TTY = Start.Y - dy;
                double TBY = Start.Y + dy;

                double BLX = End.X - dx;
                double BRX = End.X + dx;

                double BTY = End.Y - dy;
                double BBY = End.Y + dy;

                return new Point[4] { new Point(TLX, TTY), new Point(BLX, BTY), new Point(TRX, TBY), new Point(BRX, BBY) };
            }
            #endregion

            #region GetCenterPoint
            /// <summary>座標配列の中心点を求める</summary>
            /// <param name="Points">求める対象の座標配列</param>
            /// <returns>中心点</returns>
            private iPoint GetCenterPoint(iPoint[] Points)
            {
                int CX = 0, CY = 0;

                for (int i = 0; i < Points.Length; i++)
                {
                    CX += Points[i].X;
                    CY += Points[i].Y;
                }

                return new iPoint(CX / Points.Length, CY / Points.Length);
            }

            /// <summary>座標配列の中心点を求める</summary>
            /// <param name="Points">求める対象の座標配列</param>
            /// <returns>中心点</returns>
            private Point GetCenterPoint(Point[] Points)
            {
                double CX = 0, CY = 0;

                for (int i = 0; i < Points.Length; i++)
                {
                    CX += Points[i].X;
                    CY += Points[i].Y;
                }

                return new Point(CX / Points.Length, CY / Points.Length);
            }
            #endregion

            #region SetListPoints
            /// <summary>Listに外側線と内側線を接続して</summary>
            /// <param name="OutSide">外枠線を追加するList</param>
            /// <param name="InSide">内枠線を追加するList</param>
            /// <param name="P">セットする座標配列</param>
            /// <param name="IsLastRotate">最後のローテートして最初の点に戻ったかどうか(接続するとき)</param>
            private void SetListPoints(Collections.Generic.List<Point> OutSide, Collections.Generic.List<Point> InSide, Point[] P, bool IsLastRotate)
            {
                //SetIOPointsで定義したメソッドを使って内側なのか外側なのかを求める
                double _01 = this.func(P[0], P[1]);
                double _23 = this.func(P[2], P[3]);

                if (OutSide.Count < 2)
                {
                    if (_01 < _23)
                    {
                        InSide.Add(P[0]); InSide.Add(P[1]);
                        OutSide.Add(P[2]); OutSide.Add(P[3]);
                    }

                    else
                    {
                        InSide.Add(P[2]); InSide.Add(P[3]);
                        OutSide.Add(P[0]); OutSide.Add(P[1]);
                    }
                }

                else
                {
                    Collections.Generic.List<Point>[] PList = (_01 < _23 ? new System.Collections.Generic.List<Point>[] { InSide, OutSide } : new System.Collections.Generic.List<Point>[] { OutSide, InSide });

                    Point[] CrossP = new Point[2];

                    for (int i = 0; i < 2; i++)
                    {
                        // パラメータ表記の値に変換する
                        double x1 = PList[i][PList[i].Count - 2].X;
                        double y1 = PList[i][PList[i].Count - 2].Y;
                        double f1 = PList[i][PList[i].Count - 1].X - x1;
                        double g1 = PList[i][PList[i].Count - 1].Y - y1;
                        double x2 = P[i << 1].X;
                        double y2 = P[i << 1].Y;
                        double f2 = P[(i << 1) + 1].X - x2;
                        double g2 = P[(i << 1) + 1].Y - y2;

                        // detの計算
                        double det = f2 * g1 - f1 * g2;

                        if (det == 0)
                        {
                            CrossP[i] = P[i << 1];
                            continue;
                        }

                        // 交点におけるパラメータ
                        double dx = x2 - x1;
                        double dy = y2 - y1;
                        double t1 = (f2 * dy - g2 * dx) / det;
                        //t2 = (f1 * dy - g1 * dx) / det;

                        // 交点の座標
                        CrossP[i].X = x1 + f1 * t1;
                        CrossP[i].Y = y1 + g1 * t1;
                    }

                    if (_01 < _23)
                    {
                        InSide.RemoveAt(InSide.Count - 1);
                        InSide.Add(CrossP[0]); InSide.Add(P[1]);
                        OutSide.RemoveAt(OutSide.Count - 1);
                        OutSide.Add(CrossP[1]); OutSide.Add(P[3]);
                    }

                    else
                    {
                        OutSide.RemoveAt(OutSide.Count - 1);
                        OutSide.Add(CrossP[0]); OutSide.Add(P[1]);
                        InSide.RemoveAt(InSide.Count - 1);
                        InSide.Add(CrossP[1]); InSide.Add(P[3]);
                    }

                    if (IsLastRotate)
                    {
                        for (int i = 0; i < 2; i++)
                        {
                            // パラメータ表記の値に変換する
                            double x1 = PList[i][0].X;
                            double y1 = PList[i][0].Y;
                            double f1 = PList[i][1].X - x1;
                            double g1 = PList[i][1].Y - y1;
                            double x2 = P[i << 1].X;
                            double y2 = P[i << 1].Y;
                            double f2 = P[(i << 1) + 1].X - x2;
                            double g2 = P[(i << 1) + 1].Y - y2;

                            // detの計算
                            double det = f2 * g1 - f1 * g2;

                            if (det == 0)
                            {
                                CrossP[i] = P[(i << 1) + 1];
                                continue;
                            }

                            // 交点におけるパラメータ
                            double dx = x2 - x1;
                            double dy = y2 - y1;
                            double t1 = (f2 * dy - g2 * dx) / det;
                            //t2 = (f1 * dy - g1 * dx) / det;

                            // 交点の座標
                            CrossP[i].X = x1 + f1 * t1;
                            CrossP[i].Y = y1 + g1 * t1;
                        }

                        if (_01 < _23)
                        {
                            InSide.RemoveAt(0);
                            InSide.RemoveAt(InSide.Count - 1);
                            InSide.Add(CrossP[0]);
                            OutSide.RemoveAt(0);
                            OutSide.RemoveAt(OutSide.Count - 1);
                            OutSide.Add(CrossP[1]);
                        }

                        else
                        {
                            OutSide.RemoveAt(0);
                            OutSide.RemoveAt(OutSide.Count - 1);
                            OutSide.Add(CrossP[0]);
                            InSide.RemoveAt(0);
                            InSide.RemoveAt(InSide.Count - 1);
                            InSide.Add(CrossP[1]);
                        }
                    }
                }
            }
            #endregion

            #region SetIOPoints
            /// <summary>線の繋ぎを双方から考える</summary>
            /// <param name="Points">線を作成する座標配列</param>
            /// <param name="IsContinuously">この複数の座標を一つに繋がった線の集合と見るかどうか</param>
            /// <param name="OutArray">求めた外枠の線を代入する座標配列</param>
            /// <param name="InArray">求めた内枠の線を代入する座標配列</param>
            public void SetIOPoints(Point[] Points, bool IsContinuously, out Point[] OutArray, out Point[] InArray)
            {
                Collections.Generic.List<Point> OutSide, InSide;
                Point Start, End;
                Point[] P;
                OutSide = new System.Collections.Generic.List<Point>();
                InSide = new System.Collections.Generic.List<Point>();

                //SetListPointsで使うセンターポイント(重心)と内側か外側かを判断するメソッドの定義
                this.CP = GetCenterPoint(Points);

                this.func = (Point cmp, Point cmp2) =>
                {
                    return Math.Abs(this.CP.X - (cmp.X + cmp2.X) / 2.0) + Math.Abs(this.CP.Y - (cmp.Y + cmp2.Y) / 2.0);
                };

                if (IsContinuously)
                {
                    int tmp;
                    for (int i = 0; i < Points.Length; i++)
                    {
                        Start = Points[i];
                        End = Points[tmp = (i + 1).ReverseMaxClipping(0, Points.Length - 1)];

                        P = CreatePoints(Start, End);

                        SetListPoints(OutSide, InSide, P, tmp == 0);
                    }
                }

                else
                {
                    for (int i = 0; i < Points.Length - 1; i++)
                    {
                        Start = Points[i];
                        End = Points[i + 1];

                        P = CreatePoints(Start, End);

                        SetListPoints(OutSide, InSide, P, false);
                    }
                }

                OutArray = OutSide.ToArray();
                InArray = InSide.ToArray();
            }
            #endregion
        }
        #endregion

        #region DrawCopy

        #region DrawCopyPen
        /// <summary>点配列を四角形と見て描画する</summary>
        /// <param name="Pen">描画を行うPen</param>
        /// <param name="P">長方形を構成するPoint配列</param>
        /// <param name="iP">長方形を構成するiPoint配列</param>
        /// <param name="SmoothingMode">描画時の品質</param>
        /// <param name="CompositingMode">描画時の上塗りのモード</param>
        private void DrawCopyPen(Pen Pen, Point[] P, iPoint[] iP, SmoothingMode SmoothingMode, CompositingMode CompositingMode)
        {
            int ARGB = Pen.Color.ToArgb();
            byte[] BARGB = ARGB.CalcAlphaBlend();

            double MinY, MaxY, MinX, MaxX;
            int MinIndex, MaxIndex;
            int[] LIndex, RIndex;
            LIndex = new int[2] { 0, 1 };
            RIndex = new int[2] { 2, 3 };

            //左側の点と右側の点に分ける
            for (int i = 0; i < LIndex.Length; i++)
            {
                for (int j = 0; j < RIndex.Length; j++)
                {
                    if (P[LIndex[i]].X > P[RIndex[j]].X)
                        ExtraClass.Swap(ref LIndex[i], ref RIndex[j]);
                }
            }

            if (P[LIndex[0]].Y > P[LIndex[1]].Y)
                ExtraClass.Swap(ref LIndex[0], ref LIndex[1]);

            if (P[RIndex[0]].Y > P[RIndex[1]].Y)
                ExtraClass.Swap(ref RIndex[0], ref RIndex[1]);

            MinIndex = (P[LIndex[0]].Y < P[RIndex[0]].Y ? LIndex[0] : RIndex[0]);
            MinY = P[MinIndex].Y;

            MaxIndex = (P[LIndex[1]].Y > P[RIndex[1]].Y ? LIndex[1] : RIndex[1]);
            MaxY = P[MaxIndex].Y;

            MinX = P[(P[LIndex[0]].X < P[LIndex[1]].X ? LIndex[0] : LIndex[1])].X;
            MaxX = P[(P[RIndex[0]].X > P[RIndex[1]].X ? RIndex[0] : RIndex[1])].X;

            if (MaxY < 0 || MaxX < 0) return;
            if (MinY >= this.LimitSize.Height || MinX >= this.LimitSize.Width) return;

            int iMinY, iMaxY;
            int fixLX, fixRX;
            iMinY = (int)MinY;
            iMaxY = ((int)MaxY).MaxClipping(this.LimitSize.Height);
            int addL = 0, addR = 0;
            int iMaxX = this.LimitSize.Width.ToFix();
            int[] dest = new int[2];

            if (iMaxY <= 0) return;

            if (iP[LIndex[0]].Y == iP[RIndex[0]].Y)
            {
                if (P[LIndex[0]].Y == P[RIndex[0]].Y)
                    dest[0] = int.MaxValue;

                else
                    dest[0] = (P[RIndex[0]].X - P[LIndex[0]].X).ToFix() * (P[RIndex[0]].Y < P[LIndex[0]].Y ? -1 : 1);
            }

            else
                dest[0] = (P[RIndex[0]].X - P[LIndex[0]].X).ToFix() / (iP[RIndex[0]].Y - iP[LIndex[0]].Y);

            if (iP[LIndex[0]].Y == iP[LIndex[1]].Y)
            {
                if (P[LIndex[0]].Y == P[LIndex[1]].Y)
                    dest[1] = int.MaxValue;

                else
                    dest[1] = (P[LIndex[1]].X - P[LIndex[0]].X).ToFix() * (P[LIndex[1]].Y < P[LIndex[0]].Y ? -1 : 1);
            }

            else
                dest[1] = (P[LIndex[1]].X - P[LIndex[0]].X).ToFix() / (iP[LIndex[1]].Y - iP[LIndex[0]].Y);

            #region 傾きなしの長方形
            if (iP[LIndex[0]].Y == iP[RIndex[0]].Y)
            {
                if (iMinY < 0) iMinY = 0;

                #region アンチエイリアシング
                if (SmoothingMode == SmoothingMode.AntiAlias)
                {
                    fixLX = P[LIndex[0]].X.ToFix().MinClipping(0);
                    fixRX = P[RIndex[0]].X.ToFix().MaxClipping(iMaxX);

                    if (CompositingMode == CompositingMode.SourceOver)
                    {
                        int C;
                        this.DrawXLineAA(fixLX, fixRX, iMinY, C = ARGB.NewArgb((byte)(((byte)(255 * MinY.Modf())).Not() * BARGB[0] >> 8)), C.CalcAlphaBlend());
                        if (iMaxY != this.LimitSize.Height) this.DrawXLineAA(fixLX, fixRX, iMaxY, C = ARGB.NewArgb((byte)((byte)(255 * MaxY.Modf()) * BARGB[0] >> 8)), C.CalcAlphaBlend());
                        iMinY++;

                        while (iMinY != iMaxY)
                        {
                            this.DrawXLineAA(fixLX, fixRX, iMinY, ARGB, BARGB);
                            iMinY++;
                        }
                    }

                    else
                    {
                        this.CopyXLineAA(fixLX, fixRX, iMinY, ARGB.NewArgb((byte)(((byte)(255 * MinY.Modf())).Not() * BARGB[0] >> 8)));
                        if (iMaxY != this.LimitSize.Height) this.CopyXLineAA(fixLX, fixRX, iMaxY, ARGB.NewArgb((byte)((byte)(255 * MaxY.Modf()) * BARGB[0] >> 8)));
                        iMinY++;

                        while (iMinY != iMaxY)
                        {
                            this.CopyXLineAA(fixLX, fixRX, iMinY, ARGB);
                            iMinY++;
                        }
                    }
                }
                #endregion

                #region エイリアシング
                else
                {
                    int iLeft = (int)P[LIndex[0]].X.MinClipping(0);
                    int iRight = (int)Math.Ceiling(P[RIndex[0]].X).MaxClipping(this.LimitSize.Width);

                    if (CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMaxY)
                        {
                            this.DrawXLine(iLeft, iRight, iMinY, BARGB);
                            iMinY++;
                        }
                    }

                    else
                    {
                        while (iMinY != iMaxY)
                        {
                            this.CopyXLine(iLeft, iRight, iMinY, ARGB);
                            iMinY++;
                        }
                    }
                }
                #endregion
            }
            #endregion

            #region 平行四辺形
            else
            {
                int destR, destL;
                fixLX = fixRX = P[MinIndex].X.ToFix();

                if (P[LIndex[0]].Y > P[RIndex[0]].Y)
                {
                    addL = dest[0];
                    addR = dest[1];
                    destL = 1;
                    destR = 0;

                    if (iMinY < 0)
                    {
                        int over = Math.Abs(iMinY);

                        if (P[LIndex[1]].Y < 0)
                        {
                            over = iP[LIndex[1]].Y - iMinY;
                            fixLX += addL * over;
                            addL = dest[1];
                            fixLX += addL * -iP[LIndex[1]].Y;
                        }

                        else
                            fixLX += addL * over;

                        if (P[RIndex[1]].Y < 0)
                        {
                            over = iP[RIndex[1]].Y - iMinY;
                            fixRX += addR * over;
                            addR = dest[0];
                            fixRX += addR * -iP[RIndex[1]].Y;
                        }

                        else
                            fixRX += addR * over;

                        iMinY = 0;
                    }
                }

                else
                {
                    addL = dest[1];
                    addR = dest[0];
                    destL = 0;
                    destR = 1;

                    if (iMinY < 0)
                    {
                        int over = Math.Abs(iMinY);

                        if (P[LIndex[1]].Y < 0)
                        {
                            over = iP[LIndex[1]].Y - iMinY;
                            fixLX += addL * over;
                            addL = dest[0];
                            fixLX += addL * -iP[LIndex[1]].Y;
                        }

                        else
                            fixLX += addL * over;

                        if (P[RIndex[1]].Y < 0)
                        {
                            over = iP[RIndex[1]].Y - iMinY;
                            fixRX += addR * over;
                            addR = dest[1];
                            fixRX += addR * -iP[RIndex[1]].Y;
                        }

                        else
                            fixRX += addR * over;

                        iMinY = 0;
                    }
                }

                #region アンチエイリアシング
                if (SmoothingMode == SmoothingMode.AntiAlias)
                {
                    if (CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMaxY)
                        {
                            if (iMinY == iP[LIndex[destR]].Y)
                            {
                                fixLX = P[LIndex[destR]].X.ToFix();
                                addL = dest[destL];
                            }

                            if (iMinY == iP[RIndex[destL]].Y)
                            {
                                fixRX = P[RIndex[destL]].X.ToFix();
                                addR = dest[destR];
                            }

                            this.DrawXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB, BARGB);

                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }
                    }

                    else
                    {
                        while (iMinY != iMaxY)
                        {
                            if (iMinY == iP[LIndex[destR]].Y)
                            {
                                fixLX = P[LIndex[destR]].X.ToFix();
                                addL = dest[destL];
                            }

                            if (iMinY == iP[RIndex[destL]].Y)
                            {
                                fixRX = P[RIndex[destL]].X.ToFix();
                                addR = dest[destR];
                            }

                            this.CopyXLineAA(fixLX.Clipping(0, iMaxX), fixRX.Clipping(0, iMaxX), addL, addR, iMinY, ARGB);

                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }
                    }
                }
                #endregion

                #region エイリアシング
                else
                {
                    if (CompositingMode == CompositingMode.SourceOver)
                    {
                        while (iMinY != iMaxY)
                        {
                            if (iMinY == iP[LIndex[destR]].Y)
                            {
                                fixLX = P[LIndex[destR]].X.ToFix();
                                addL = dest[destL];
                            }

                            if (iMinY == iP[RIndex[destL]].Y)
                            {
                                fixRX = P[RIndex[destL]].X.ToFix();
                                addR = dest[destR];
                            }

                            this.DrawXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Ceiling().Clipping(0, iMaxX).iPart(), iMinY, BARGB);

                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }
                    }

                    else
                    {
                        while (iMinY != iMaxY)
                        {
                            if (iMinY == iP[LIndex[destR]].Y)
                            {
                                fixLX = P[LIndex[destR]].X.ToFix();
                                addL = dest[destL];
                            }

                            if (iMinY == iP[RIndex[destL]].Y)
                            {
                                fixRX = P[RIndex[destL]].X.ToFix();
                                addR = dest[destR];
                            }

                            this.CopyXLine(fixLX.Clipping(0, iMaxX).iPart(), fixRX.Ceiling().Clipping(0, iMaxX).iPart(), iMinY, ARGB);

                            fixLX += addL;
                            fixRX += addR;
                            iMinY++;
                        }
                    }
                }
                #endregion
            }
            #endregion
        }
        #endregion

        #region DrawCopyPens
        /// <summary>点配列を多角形と見て描画する</summary>
        /// <param name="Pen">描画を行うPen</param>
        /// <param name="OutPoints">外側の点配列</param>
        /// <param name="InPoints">内側の点配列</param>
        /// <param name="SmoothingMode">描画時の品質</param>
        /// <param name="CompositingMode">描画時の上塗りのモード</param>
        /// <param name="IsContinuously">連続した点の集合と見なすかどうか</param>
        private void DrawCopyPens(Pen Pen, Point[] OutPoints, Point[] InPoints, SmoothingMode SmoothingMode, CompositingMode CompositingMode, bool IsContinuously)
        {
            if (OutPoints.Length != InPoints.Length) throw new ArgumentException("OutPointsとInPointsの点の数は同じでなければなりません。", "OutPoints , InPoints");

            int tmp;

            //for (int i = 0; i < OutPoints.Length; i++)
            //{
            //    tmp = i + 1; if (tmp >= OutPoints.Length) tmp = 0;
            //    DrawPenAA(Pens.Red, OutPoints[i], OutPoints[tmp]);
            //    DrawPenAA(Pens.Green, InPoints[i], InPoints[tmp]);
            //}

            //return;

            double MinY, MaxY, MinX, MaxX;
            int MinIndex, MaxIndex;

            MinY = OutPoints[MinIndex = 0].Y;
            MaxY = OutPoints[MaxIndex = 0].Y;
            MinX = OutPoints[0].X;
            MaxX = OutPoints[0].X;

            for (int i = 1; i < OutPoints.Length; i++)
            {
                if (MinY > OutPoints[i].Y) MinY = OutPoints[MinIndex = i].Y;
                if (MaxY < OutPoints[i].Y) MaxY = OutPoints[MaxIndex = i].Y;
                if (MinX > OutPoints[i].X) MinX = OutPoints[i].X;
                if (MaxX < OutPoints[i].X) MaxX = OutPoints[i].X;
            }

            if (MaxY < 0 || MaxX < 0) return;
            if (MinY >= this.LimitSize.Height || MinX >= this.LimitSize.Width) return;

            System.Collections.Generic.List<FixLine> SideList = new System.Collections.Generic.List<FixLine>(OutPoints.Length);

            if (IsContinuously)
            {
                for (int i = 0; i < OutPoints.Length; i++)
                {
                    tmp = i + 1; if (tmp >= OutPoints.Length) tmp = 0;
                    SideList.Add(FixLine.FromXLine(OutPoints[i], OutPoints[tmp], FixPointConstants.FixX));
                    SideList.Add(FixLine.FromXLine(InPoints[i], InPoints[tmp], FixPointConstants.FixX));
                }
            }

            else
            {
                for (int i = 0; i < OutPoints.Length - 1; i++)
                {
                    tmp = i + 1;
                    SideList.Add(FixLine.FromXLine(OutPoints[i], OutPoints[tmp], FixPointConstants.FixX));
                    SideList.Add(FixLine.FromXLine(InPoints[i], InPoints[tmp], FixPointConstants.FixX));
                }

                SideList.Add(FixLine.FromXLine(OutPoints[0], InPoints[0], FixPointConstants.FixX));
                SideList.Add(FixLine.FromXLine(OutPoints[OutPoints.Length - 1], InPoints[OutPoints.Length - 1], FixPointConstants.FixX));
            }

            FixLineCalc Calc = new FixLineCalc(SideList);
            Calc.Clipping(0, this.LimitSize.Height - 1);

            int iMinY, iMaxY;
            iMinY = (int)Math.Floor(MinY).MinClipping(0);
            iMaxY = ((int)Math.Ceiling(MaxY)).MaxClipping(this.LimitSize.Height);
            int iMaxX = this.LimitSize.Width.ToFix();

            int ARGB = Pen.Color.ToArgb();
            byte[] BARGB = ARGB.CalcAlphaBlend();

            if (iMaxY <= 0) return;

            #region アンチエイリアシング
            if (SmoothingMode == SmoothingMode.AntiAlias)
            {
                Collections.Generic.List<PluralsValue<int, int>> FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Count; i += 2)
                            this.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB, BARGB);

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Count; i += 2)
                            this.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, ARGB);

                        iMinY++;
                    }
                }
            }
            #endregion

            #region エイリアシング
            else
            {
                Collections.Generic.List<int> FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Count; i += 2)
                            this.DrawXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, BARGB);

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Count; i += 2)
                            this.CopyXLine(FixX[i].Clipping(0, iMaxX).iPart(), FixX[i + 1].Clipping(0, iMaxX).iPart(), iMinY, ARGB);

                        iMinY++;
                    }
                }
            }
            #endregion
        }
        #endregion

        #endregion

        #region Copy

        #region CopyPen
        /// <summary>Penを使った線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        internal void CopyPen(Pen Pen, int StartX, int StartY, int EndX, int EndY)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, StartX, StartY, EndX, EndY, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.Default, CompositingMode.SourceCopy);
        }

        /// <summary>Penを使った線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        internal void CopyPen(Pen Pen, iPoint Start, iPoint End)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, Start, End, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.Default, CompositingMode.SourceCopy);
        }

        /// <summary>Penを使った線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        internal void CopyPenAA(Pen Pen, double StartX, double StartY, double EndX, double EndY)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, StartX, StartY, EndX, EndY, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.AntiAlias, CompositingMode.SourceCopy);
        }

        /// <summary>Penを使った線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        internal void CopyPenAA(Pen Pen, Point Start, Point End)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, Start, End, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.AntiAlias, CompositingMode.SourceCopy);
        }
        #endregion

        #region CopyPens
        /// <summary>Penを使った連続している複数の線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Points">描画する線の座標配列</param>
        /// <param name="IsContinuously">この複数の座標を一つに繋がった線の集合と見るかどうか</param>
        internal void CopyPens(Pen Pen, Point[] Points, bool IsContinuously)
        {
            Point[] OutSide, InSide;

            CreateLines CL = new CreateLines(Pen);
            CL.SetIOPoints(Points, IsContinuously, out OutSide, out InSide);

            DrawCopyPens(Pen, OutSide, InSide, SmoothingMode.Default, CompositingMode.SourceCopy, IsContinuously);
        }

        /// <summary>Penを使った連続している複数の線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Points">描画する線の座標配列</param>
        /// <param name="IsContinuously">この複数の座標を一つに繋がった線の集合と見るかどうか</param>
        internal void CopyPensAA(Pen Pen, Point[] Points, bool IsContinuously)
        {
            Point[] OutSide, InSide;

            CreateLines CL = new CreateLines(Pen);
            CL.SetIOPoints(Points, IsContinuously, out OutSide, out InSide);

            DrawCopyPens(Pen, OutSide, InSide, SmoothingMode.AntiAlias, CompositingMode.SourceCopy, IsContinuously);
        }
        #endregion

        #endregion

        #region Draw

        #region DrawPen
        /// <summary>Penを使った線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        internal void DrawPen(Pen Pen, int StartX, int StartY, int EndX, int EndY)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, StartX, StartY, EndX, EndY, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.Default, CompositingMode.SourceOver);
        }

        /// <summary>Penを使った線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        internal void DrawPen(Pen Pen, iPoint Start, iPoint End)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, Start, End, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.Default, CompositingMode.SourceOver);
        }

        /// <summary>Penを使った線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="StartX">始点X</param>
        /// <param name="StartY">始点Y</param>
        /// <param name="EndX">終点X</param>
        /// <param name="EndY">終点Y</param>
        internal void DrawPenAA(Pen Pen, double StartX, double StartY, double EndX, double EndY)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, StartX, StartY, EndX, EndY, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.AntiAlias, CompositingMode.SourceOver);
        }

        /// <summary>Penを使った線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Start">始点</param>
        /// <param name="End">終点</param>
        internal void DrawPenAA(Pen Pen, Point Start, Point End)
        {
            iPoint[] iP;
            Point[] P = CreateLines.CreatePoints(Pen.Width, Start, End, out iP);

            DrawCopyPen(Pen, P, iP, SmoothingMode.AntiAlias, CompositingMode.SourceOver);
        }
        #endregion

        #region DrawPens
        /// <summary>Penを使った連続している複数の線をαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Points">描画する線の座標配列</param>
        /// <param name="IsContinuously">この複数の座標を一つに繋がった線の集合と見るかどうか</param>
        internal void DrawPens(Pen Pen, Point[] Points, bool IsContinuously)
        {
            Point[] OutSide, InSide;

            CreateLines CL = new CreateLines(Pen);
            CL.SetIOPoints(Points, IsContinuously, out OutSide, out InSide);

            DrawCopyPens(Pen, OutSide, InSide, SmoothingMode.Default, CompositingMode.SourceOver, IsContinuously);
        }

        /// <summary>Penを使った連続している複数の線をAntiAliasを施してαブレンド描画する</summary>
        /// <param name="Pen">描画する線のパラメータを含んだPen</param>
        /// <param name="Points">描画する線の座標配列</param>
        /// <param name="IsContinuously">この複数の座標を一つに繋がった線の集合と見るかどうか</param>
        internal void DrawPensAA(Pen Pen, Point[] Points, bool IsContinuously)
        {
            Point[] OutSide, InSide;

            CreateLines CL = new CreateLines(Pen);
            CL.SetIOPoints(Points, IsContinuously, out OutSide, out InSide);

            DrawCopyPens(Pen, OutSide, InSide, SmoothingMode.AntiAlias, CompositingMode.SourceOver, IsContinuously);
        }
        #endregion

        #endregion

        #endregion

        #region 図形の横線構築メソッド

        #region 単色塗り

        #region CopyLine
        /// <summary>横線を上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;=Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="DrawColor">設定する色情報(ARGB形式)</param>
        internal void CopyXLine(int X1, int X2, int Y, int DrawColor)
        {
            DrawColor = DrawColor.AlphaBlend();

            while (X1 != X2)
            {
                SetPixel(X1, Y, DrawColor);
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="DrawColor">設定する色情報(ARGB形式)</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int Y, int DrawColor)
        {
            byte Alpha = (byte)(DrawColor >> 24);
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, DrawColor, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlendCopy(iX1, Y, DrawColor, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
            if (iX2 != this.LimitSize.Width) SetPixelBlendCopy(iX2, Y, DrawColor, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            iX1++;

            DrawColor = DrawColor.AlphaBlend();

            while (iX1 != iX2)
            {
                SetPixel(iX1, Y, DrawColor);
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="DrawColor">設定する色情報(ARGB形式)</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, int DrawColor)
        {
            byte Alpha = (byte)(DrawColor >> 24);
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, DrawColor, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                    SetPixelBlendCopy(inextX, Y, DrawColor, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlendCopy(iX1, Y, DrawColor, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    SetPixelBlendCopy(inextX, Y, DrawColor, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
                SetPixelBlendCopy(iX2, Y, DrawColor, (byte)(fixX2.fPartToByte() * Alpha >> 8));

            DrawColor = DrawColor.AlphaBlend();

            while (iX1 != iX2)
            {
                SetPixel(iX1, Y, DrawColor);
                iX1++;
            }
        }
        #endregion

        #region DrawLine
        /// <summary>横線をαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;=Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="ARGB">既に計算された設定する色情報のバイト配列(ARGB形式)</param>
        internal void DrawXLine(int X1, int X2, int Y, byte[] ARGB)
        {
            while (X1 != X2)
            {
                SetPixelQBlend(X1, Y, ARGB);
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="DrawColor">設定する色情報(ARGB形式)</param>
        /// <param name="ARGB">既に計算されたARGB形式のバイト配列</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int Y, int DrawColor, byte[] ARGB)
        {
            byte Alpha = (byte)(DrawColor >> 24);
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, DrawColor, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlend(iX1, Y, DrawColor, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
            if (iX2 != this.LimitSize.Width) SetPixelBlend(iX2, Y, DrawColor, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            iX1++;

            while (iX1 != iX2)
            {
                SetPixelQBlend(iX1, Y, ARGB);
                iX1++;
            }
        }

        /// <summary>横線に高精度にAntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="DrawColor">設定する色情報(ARGB形式)</param>
        /// <param name="ARGB">既に計算されたARGB形式のバイト配列</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, int DrawColor, byte[] ARGB)
        {
            byte Alpha = (byte)(DrawColor >> 24);
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, DrawColor, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                    SetPixelBlend(inextX, Y, DrawColor, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlend(iX1, Y, DrawColor, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    SetPixelBlend(inextX, Y, DrawColor, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
                SetPixelBlend(iX2, Y, DrawColor, (byte)(fixX2.fPartToByte() * Alpha >> 8));

            while (iX1 != iX2)
            {
                SetPixelQBlend(iX1, Y, ARGB);
                iX1++;
            }
        }
        #endregion

        #endregion

        #region 多色塗り

        #region CopyLine
        /// <summary>横線を関数で色取得しながら上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void CopyXLine(int X1, int X2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            while (X1 != X2)
            {
                SetPixelBlendCopy(X1, Y, GetDrawColorMethod(X1, Y));
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施して関数で色取得しながら上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = GetDrawColorMethod(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = GetDrawColorMethod(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, GetDrawColorMethod(iX1, Y));
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施して関数で色取得しながら上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = GetDrawColorMethod(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = GetDrawColorMethod(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = GetDrawColorMethod(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = GetDrawColorMethod(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, GetDrawColorMethod(iX1, Y));
                iX1++;
            }
        }
        #endregion

        #region DrawLine
        /// <summary>横線を関数で色取得しながらαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;=Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void DrawXLine(int X1, int X2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            while (X1 != X2)
            {
                SetPixelBlend(X1, Y, GetDrawColorMethod(X1, Y));
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施して関数で色取得しながらαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = GetDrawColorMethod(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = GetDrawColorMethod(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, GetDrawColorMethod(iX1, Y));
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施して関数で色取得しながらαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="GetDrawColorMethod">設定する色情報(ARGB形式)を取得するメソッド(int Func(int X,int Y))</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, Func<int, int, int> GetDrawColorMethod)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = GetDrawColorMethod(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = GetDrawColorMethod(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = GetDrawColorMethod(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = GetDrawColorMethod(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, GetDrawColorMethod(iX1, Y));
                iX1++;
            }
        }
        #endregion

        #endregion

        #region イメージ塗り

        #region 回転・拡大縮小なし

        #region CopyLine
        /// <summary>横線を上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void CopyXLine(int X1, int X2, int Y, CustomWriteableBitmap Source)
        {
            while (X1 != X2)
            {
                SetPixelBlendCopy(X1, Y, Source.GetPixel(X1, Y));
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int Y, CustomWriteableBitmap Source)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = Source.GetPixel(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixel(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, Source.GetPixel(iX1, Y));
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, CustomWriteableBitmap Source)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = Source.GetPixel(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = Source.GetPixel(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = Source.GetPixel(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixel(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, Source.GetPixel(iX1, Y));
                iX1++;
            }
        }
        #endregion

        #region DrawLine
        /// <summary>横線をαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;=Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void DrawXLine(int X1, int X2, int Y, CustomWriteableBitmap Source)
        {
            while (X1 != X2)
            {
                SetPixelBlend(X1, Y, Source.GetPixel(X1, Y));
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int Y, CustomWriteableBitmap Source)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = Source.GetPixel(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixel(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, Source.GetPixel(iX1, Y));
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, CustomWriteableBitmap Source)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();
            int TC = Source.GetPixel(iX1, Y);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = Source.GetPixel(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX1 += cnt1;
            }

            else
            {
                SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = Source.GetPixel(inextX, Y);
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixel(iX2, Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, Source.GetPixel(iX1, Y));
                iX1++;
            }
        }
        #endregion

        #endregion

        #region 回転・拡大縮小あり

        #region CopyLine
        /// <summary>横線を上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="SrcStart">イメージを取得する始点</param>
        /// <param name="SrcEnd">イメージを取得する終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void CopyXLine(int X1, int X2, int Y, CustomWriteableBitmap Source, iPoint SrcStart, iPoint SrcEnd, int dU, int dV)
        {
            int SX = SrcStart.X;
            int SY = SrcStart.Y;

            while (X1 != X2)
            {
                SetPixelBlendCopy(X1, Y, Source.GetPixel(SX.iPart(), SY.iPart()));
                SX += dU;
                SY += dV;
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="FixSrcStart">イメージを取得する固定小数表記の始点</param>
        /// <param name="FixSrcEnd">イメージを取得する固定小数表記の終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int Y, CustomWriteableBitmap Source, iPoint FixSrcStart, iPoint FixSrcEnd, int dU, int dV)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            int FSX = FixSrcStart.X;
            int FSY = FixSrcStart.Y;

            int TC = Source.GetPixelAA(FSX, FSY);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, Source.GetPixelAA(FSX, FSY));
                FSX += dU;
                FSY += dV;
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施して上塗り描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="FixSrcStart">イメージを取得する固定小数表記の始点</param>
        /// <param name="FixSrcEnd">イメージを取得する固定小数表記の終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void CopyXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, CustomWriteableBitmap Source, iPoint FixSrcStart, iPoint FixSrcEnd, int dU, int dV)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            int FSX = FixSrcStart.X;
            int FSY = FixSrcStart.Y;

            int TC = Source.GetPixelAA(FSX, FSY);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = Source.GetPixelAA(FSX, FSY);
                    FSX += dU;
                    FSY += dV;
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                FSX -= dU;
                FSY -= dV;
                iX1 += cnt1;
            }

            else
            {
                SetPixelBlendCopy(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                    FixSrcEnd.X -= dU;
                    FixSrcEnd.Y -= dV;
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlendCopy(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlendCopy(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlendCopy(iX1, Y, Source.GetPixelAA(FSX, FSY));
                FSX += dU;
                FSY += dV;
                iX1++;
            }
        }
        #endregion

        #region DrawLine
        /// <summary>横線をαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="X1">始点X(0&lt;=X1&lt;=Width)</param>
        /// <param name="X2">終点X(0&lt;=X2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="SrcStart">イメージを取得する始点</param>
        /// <param name="SrcEnd">イメージを取得する終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void DrawXLine(int X1, int X2, int Y, CustomWriteableBitmap Source, iPoint SrcStart, iPoint SrcEnd, int dU, int dV)
        {
            int SX = SrcStart.X;
            int SY = SrcStart.Y;

            while (X1 != X2)
            {
                SetPixelBlend(X1, Y, Source.GetPixel(SX.iPart(), SY.iPart()));
                SX += dU;
                SY += dV;
                X1++;
            }
        }

        /// <summary>横線にAntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="FixSrcStart">イメージを取得する固定小数表記の始点</param>
        /// <param name="FixSrcEnd">イメージを取得する固定小数表記の終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int Y, CustomWriteableBitmap Source, iPoint FixSrcStart, iPoint FixSrcEnd, int dU, int dV)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            int FSX = FixSrcStart.X;
            int FSY = FixSrcStart.Y;

            int TC = Source.GetPixelAA(FSX, FSY);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));

            if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            iX1++;

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, Source.GetPixelAA(FSX, FSY));
                FSX += dU;
                FSY += dV;
                iX1++;
            }
        }

        /// <summary>横線に高精度AntiAliasを施してαブレンド描画する(X1&lt;=X2)</summary>
        /// <param name="fixX1">固定小数表記の始点X(0&lt;=fixX1&lt;=Width)</param>
        /// <param name="fixX2">固定小数表記の終点X(0&lt;=fixX2&lt;=Width)</param>
        /// <param name="fixAddX1">始点側の固定小数表記の傾き</param>
        /// <param name="fixAddX2">終点側の固定小数表記の傾き</param>
        /// <param name="Y">始終点Y(0&lt;=Y&lt;Height)</param>
        /// <param name="Source">イメージを取得する対象</param>
        /// <param name="FixSrcStart">イメージを取得する固定小数表記の始点</param>
        /// <param name="FixSrcEnd">イメージを取得する固定小数表記の終点</param>
        /// <param name="dU">イメージの始点から終点までの増加単位X</param>
        /// <param name="dV">イメージの始点から終点までの増加単位Y</param>
        internal void DrawXLineAA(int fixX1, int fixX2, int fixAddX1, int fixAddX2, int Y, CustomWriteableBitmap Source, iPoint FixSrcStart, iPoint FixSrcEnd, int dU, int dV)
        {
            int iX1 = fixX1.iPart();
            int iX2 = fixX2.iPart();

            int FSX = FixSrcStart.X;
            int FSY = FixSrcStart.Y;

            int TC = Source.GetPixelAA(FSX, FSY);
            byte Alpha = (byte)(TC >> 24);

            if (iX1 == this.LimitSize.Width)
                return;

            if (iX1 == iX2)
            {
                SetPixelBlend(iX1, Y, TC, (byte)((fixX2 - fixX1).fPartToByte() * Alpha >> 8));
                return;
            }

            int absAdd1 = (fixAddX1 < 0 ? -fixAddX1 : fixAddX1);
            int absAdd2 = (fixAddX2 < 0 ? -fixAddX2 : fixAddX2);
            int cnt1 = absAdd1.Ceiling().iPart().MaxClipping(0xFF);
            int cnt2 = absAdd2.Ceiling().iPart().MaxClipping(0xFF);
            int size = iX2 - iX1;
            int cntSize = cnt1 + cnt2;

            if (size < 4)
                absAdd1 = absAdd2 = 0;

            else if (size < cntSize)
            {
                cnt1 = ((size * cnt1) / cntSize).MinClipping(1);
                cnt2 = ((size * cnt2) / cntSize).MinClipping(1);
            }

            if (absAdd1 > 0x10000)
            {
                int opacity = fixX1.fPartToByte().Not() << 6;
                int addOpacity = 0x10000 / cnt1;

                int inextX;
                int ibackX;

                if (fixAddX1 < 0)
                {
                    inextX = iX1;
                    ibackX = (fixX1 - fixAddX1).iPart();
                }

                else
                {
                    inextX = iX1;
                    ibackX = (fixX1 + fixAddX1).iPart();
                }

                if (ibackX - inextX > cnt1) ibackX = inextX + cnt1;

                for (; inextX <= ibackX; opacity += addOpacity, inextX++)
                {
                    TC = Source.GetPixelAA(FSX, FSY);
                    FSX += dU;
                    FSY += dV;
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                FSX -= dU;
                FSY -= dV;
                iX1 += cnt1;
            }

            else
            {
                SetPixelBlend(iX1, Y, TC, (byte)(fixX1.fPartToByte().Not() * Alpha >> 8));
                iX1++;
            }

            if (absAdd2 > 0x10000)
            {
                int opacity = fixX2.fPartToByte() << 6;
                int addOpacity = 0x10000 / cnt2;

                int inextX;
                int ibackX;

                if (fixAddX2 > 0)
                {
                    inextX = iX2;
                    ibackX = (fixX2 - fixAddX2).iPart();
                }

                else
                {
                    inextX = iX2;
                    ibackX = (fixX2 + fixAddX2).iPart();
                }

                if (inextX - ibackX > cnt2) ibackX = inextX - cnt2;

                for (; inextX >= ibackX; opacity += addOpacity, inextX--)
                {
                    if (inextX >= this.LimitSize.Width)
                        continue;

                    TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                    FixSrcEnd.X -= dU;
                    FixSrcEnd.Y -= dV;
                    Alpha = (byte)(TC >> 24);

                    SetPixelBlend(inextX, Y, TC, (byte)(opacity.MaxClipping(0xFF00).fPartToByte() * Alpha >> 8));
                }

                iX2 -= (cnt2 - 1);
            }

            else if (iX2 != this.LimitSize.Width)
            {
                TC = Source.GetPixelAA(FixSrcEnd.X, FixSrcEnd.Y);
                Alpha = (byte)(TC >> 24);
                SetPixelBlend(iX2, Y, TC, (byte)(fixX2.fPartToByte() * Alpha >> 8));
            }

            while (iX1 != iX2)
            {
                SetPixelBlend(iX1, Y, Source.GetPixelAA(FSX, FSY));
                FSX += dU;
                FSY += dV;
                iX1++;
            }
        }
        #endregion

        #endregion

        #endregion

        #endregion

        #region イメージ描画メソッド

        #region BitBltCopy

        #region 不透明度指定なし
        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="DestLeft">自身のWriteableBitmapに描画する始めの左端X</param>
        /// <param name="DestTop">自身のWriteableBitmapに描画する始めの上端Y</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltCopy(double DestLeft, double DestTop, CustomWriteableBitmap Source, RasterOperation RasterOP)
        {
            int Left;
            int Top = (int)DestTop;

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).AddBlend());
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).SubBlend());
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).MulBlend());
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).DivBlend());
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).Not(bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb().Not(bit), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        Left = (int)DestLeft; SrcLeft = 0;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            Left++; SrcLeft++;
                        }

                        Top++; SrcTop++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltCopy(Rect RectParameter, CustomWriteableBitmap Source, RasterOperation RasterOP)
        {
            int Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).AddBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).SubBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).MulBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).DivBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="SrcParamaeter">転送元からイメージを取得する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="Quality">転送方法の品質</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltCopy(Rect RectParameter, iRect SrcParamaeter, CustomWriteableBitmap Source, SmoothingMode Quality, RasterOperation RasterOP)
        {
            int Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int FixLeft = SrcParamaeter.Left.ToFix();
            int SrcFixLeft;
            int SrcFixTop = SrcParamaeter.Top.ToFix();

            int addX = (SrcParamaeter.Width / RectParameter.Width).ToFix();
            int addY = (SrcParamaeter.Height / RectParameter.Height).ToFix();

            const int bit = 0xFFFFFF;

            #region バイリニアフィルタリング
            if (Quality == SmoothingMode.HighQuality)
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlendCopy(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).AddBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).SubBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).MulBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).DivBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Xor(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion

            #region ニアレストネイバー
            else
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).AddBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).SubBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).MulBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).DivBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion
        }
        #endregion

        #region 不透明度指定あり
        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="DestLeft">自身のWriteableBitmapに描画する始めの左端X</param>
        /// <param name="DestTop">自身のWriteableBitmapに描画する始めの上端Y</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltCopy(double DestLeft, double DestTop, CustomWriteableBitmap Source, RasterOperation RasterOP, byte Opacity)
        {
            int Left;
            int Top = (int)DestTop;

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).AddBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).SubBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).MulBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).DivBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltCopy(Rect RectParameter, CustomWriteableBitmap Source, RasterOperation RasterOP, byte Opacity)
        {
            int Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).AddBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).SubBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).MulBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity).DivBlend());
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, 0.Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を無視して(自身の色を無色#00000000として)転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="SrcParamaeter">転送元からイメージを取得する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="Quality">転送方法の品質</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltCopy(Rect RectParameter, iRect SrcParamaeter, CustomWriteableBitmap Source, SmoothingMode Quality, RasterOperation RasterOP, byte Opacity)
        {
            int Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int FixLeft = SrcParamaeter.Left.ToFix();
            int SrcFixLeft;
            int SrcFixTop = SrcParamaeter.Top.ToFix();

            int addX = (SrcParamaeter.Width / RectParameter.Width).ToFix();
            int addY = (SrcParamaeter.Height / RectParameter.Height).ToFix();

            const int bit = 0xFFFFFF;

            #region バイリニアフィルタリング
            if (Quality == SmoothingMode.HighQuality)
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlendCopy(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).AddBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).SubBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).MulBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).DivBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Xor(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion

            #region ニアレストネイバー
            else
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlendCopy(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity).AddBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity).SubBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity).MulBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity).DivBlend());
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Xor(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Not(bit).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, 0.Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, 0.Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion
        }
        #endregion

        #endregion

        #region BitBltBlend

        #region 不透明度指定なし
        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="DestLeft">自身のWriteableBitmapに描画する始めの左端X</param>
        /// <param name="DestTop">自身のWriteableBitmapに描画する始めの上端Y</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltBlend(double DestLeft, double DestTop, CustomWriteableBitmap Source, RasterOperation RasterOP)
        {
            int Left;
            int Top = (int)DestTop;

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlend(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltBlend(Rect RectParameter, CustomWriteableBitmap Source, RasterOperation RasterOP)
        {
            int Left = (int)RectParameter.Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlend(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcLeft, SrcTop)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="SrcParamaeter">転送元からイメージを取得する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="Quality">転送方法の品質</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        public void BitBltBlend(Rect RectParameter, iRect SrcParamaeter, CustomWriteableBitmap Source, SmoothingMode Quality, RasterOperation RasterOP)
        {
            int Left = (int)RectParameter.Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int FixLeft = SrcParamaeter.Left.ToFix();
            int SrcFixLeft;
            int SrcFixTop = SrcParamaeter.Top.ToFix();

            int addX = (SrcParamaeter.Width / RectParameter.Width).ToFix();
            int addY = (SrcParamaeter.Height / RectParameter.Height).ToFix();

            const int bit = 0xFFFFFF;

            #region バイリニアフィルタリング
            if (Quality == SmoothingMode.HighQuality)
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlend(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion

            #region ニアレストネイバー
            else
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlend(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart())));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart())));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart())));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart())));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion
        }
        #endregion

        #region 不透明度指定あり
        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="DestLeft">自身のWriteableBitmapに描画する始めの左端X</param>
        /// <param name="DestTop">自身のWriteableBitmapに描画する始めの上端Y</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltBlend(double DestLeft, double DestTop, CustomWriteableBitmap Source, RasterOperation RasterOP, byte Opacity)
        {
            int Left;
            int Top = (int)DestTop;

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlend(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < this.LimitSize.Height && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)DestLeft;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < this.LimitSize.Width && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltBlend(Rect RectParameter, CustomWriteableBitmap Source, RasterOperation RasterOP, byte Opacity)
        {
            int Left = (int)RectParameter.Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int SrcLeft;
            int SrcTop = 0;

            if (Top < 0)
            {
                SrcTop = -Top;
                Top = 0;
            }

            const int bit = 0xFFFFFF;

            #region ラスターオペレーションでの組み分け
            switch (RasterOP)
            {
                case RasterOperation.SrcAlpha:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixelBlend(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAdd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcSub:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcMul:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcDiv:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity)));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewBlendArgb(Opacity));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcAnd:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.SrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.NotSrcErase:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergeCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.MergePaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcLeft, SrcTop).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatCopy:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, this.PColor);
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatPaint:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.PatInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.DstInvert:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Blackness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFF000000));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;

                case RasterOperation.Whiteness:
                    while (Top < Bottom && SrcTop < Source.PixelHeight)
                    {
                        SrcLeft = 0; Left = (int)RectParameter.Left;

                        if (Left < 0)
                        {
                            SrcLeft = -Left;
                            Left = 0;
                        }

                        while (Left < Right && SrcLeft < Source.PixelWidth)
                        {
                            SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));
                            SrcLeft++; Left++;
                        }

                        SrcTop++;
                        Top++;
                    }
                    break;
            }
            #endregion
        }

        /// <summary>イメージを自身のWriteableBitmapに自身を考慮して転送する</summary>
        /// <param name="RectParameter">自身のWriteableBitmapに描画する範囲</param>
        /// <param name="SrcParamaeter">転送元からイメージを取得する範囲</param>
        /// <param name="Source">転送元のCustomWriteableBitmap</param>
        /// <param name="Quality">転送方法の品質</param>
        /// <param name="RasterOP">転送時のブレンド方法</param>
        /// <param name="Opacity">転送の際に設定する不透明度を0～255で指定する</param>
        public void BitBltBlend(Rect RectParameter, iRect SrcParamaeter, CustomWriteableBitmap Source, SmoothingMode Quality, RasterOperation RasterOP, byte Opacity)
        {
            int Left = (int)RectParameter.Left;
            int Right = (int)Math.Ceiling(RectParameter.Right);
            int Top = (int)RectParameter.Top;
            int Bottom = (int)Math.Ceiling(RectParameter.Bottom);

            int FixLeft = SrcParamaeter.Left.ToFix();
            int SrcFixLeft;
            int SrcFixTop = SrcParamaeter.Top.ToFix();

            int addX = (SrcParamaeter.Width / RectParameter.Width).ToFix();
            int addY = (SrcParamaeter.Height / RectParameter.Height).ToFix();

            const int bit = 0xFFFFFF;

            #region バイリニアフィルタリング
            if (Quality == SmoothingMode.HighQuality)
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlend(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixelAA(SrcFixLeft, SrcFixTop).NewBlendArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion

            #region ニアレストネイバー
            else
            {
                switch (RasterOP)
                {
                    case RasterOperation.SrcAlpha:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixelBlend(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAdd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).AddBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcSub:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).SubBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcMul:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).MulBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcDiv:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).DivBlend(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity)));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewBlendArgb(Opacity));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcPaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcAnd:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcInvert:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.SrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit).And(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.NotSrcErase:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb(), bit).Not(bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergeCopy:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).And(this.PColor.CalcAlphaBlendToArgb(), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.MergePaint:
                        while (Top != Bottom)
                        {
                            SrcFixLeft = FixLeft;

                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                            {
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(Source.GetPixel(SrcFixLeft.iPart(), SrcFixTop.iPart()).NewArgb(Opacity).CalcAlphaBlendToArgb().Not(bit), bit));
                                SrcFixLeft += addX;
                            }

                            SrcFixTop += addY;
                            Top++;
                        }
                        break;

                    case RasterOperation.PatCopy:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, this.PColor);

                            Top++;
                        }
                        break;

                    case RasterOperation.PatPaint:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Or(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.PatInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Xor(this.PColor.CalcAlphaBlendToArgb(), bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.DstInvert:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, GetPixel(Left, Top).Not(bit));

                            Top++;
                        }
                        break;

                    case RasterOperation.Blackness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFF000000));

                            Top++;
                        }
                        break;

                    case RasterOperation.Whiteness:
                        while (Top != Bottom)
                        {
                            for (Left = (int)RectParameter.Left; Left != Right; Left++)
                                SetPixel(Left, Top, unchecked((int)0xFFFFFFFF));

                            Top++;
                        }
                        break;
                }
            }
            #endregion
        }
        #endregion

        #endregion

        #region TextureMapping
        /// <summary>テクスチャマッピングをする</summary>
        /// <param name="Source">描画するテクスチャ</param>
        /// <param name="DestPoints">描画場所を指定したPointRect</param>
        /// <param name="SmoothingMode">描画時の品質</param>
        /// <param name="CompositingMode">上塗りの方法</param>
        /// <remarks>注意
        /// <para>指定したDestPointsが形作る四角形に180°を超える角度が入ってきた場合テクスチャが不連続になる事があります。</para></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">DestPointsの点の数が4つではない場合に発生</exception>
        public void TextureMapping(CustomWriteableBitmap Source, Point[] DestPoints, SmoothingMode SmoothingMode, CompositingMode CompositingMode)
        {
            if (DestPoints.Length != 4)
                throw new ArgumentOutOfRangeException("DestPoints", "DestPointsの点の数が4つではありません。");

            Point[] SrcPoints = new Point[] { new Point(0, 0), new Point(Source.PixelWidth - 1, 0), new Point(Source.PixelWidth - 1, Source.PixelHeight - 1), new Point(0, Source.PixelHeight - 1) };

            double MinY = DestPoints[0].Y;
            double MaxY = DestPoints[0].Y;

            for (int i = 1; i < 4; i++)
            {
                if (MinY > DestPoints[i].Y) MinY = DestPoints[i].Y;
                if (MaxY < DestPoints[i].Y) MaxY = DestPoints[i].Y;
            }

            ExtraClass.Clipping(ref MinY, 0, this.LimitSize.Height - 1);
            ExtraClass.Clipping(ref MaxY, 0, this.LimitSize.Height - 1);

            FixLine[,] SideList = new FixLine[2, 4];
            int tmp;
            for (int i = 0; i < 4; i++)
            {
                tmp = i + 1; if (tmp >= 4) tmp = 0;
                SideList[0, i] = FixLine.FromXLine(DestPoints[i], DestPoints[tmp], FixPointConstants.FixX);
                SideList[1, i] = FixLine.FromXLine(SrcPoints[i], SrcPoints[tmp], FixPointConstants.FixBoth);
            }

            FixLineImageCalc Calc = new FixLineImageCalc(SideList);

            int iMinY, iMaxY;
            iMinY = (int)Math.Floor(MinY).MinClipping(0);
            iMaxY = ((int)Math.Ceiling(MaxY)).MaxClipping(this.LimitSize.Height);
            int iMaxX = this.LimitSize.Width.ToFix();

            int dU = 0, dV = 0;

            #region アンチエイリアシング
            if (SmoothingMode == SmoothingMode.AntiAlias)
            {
                PluralsValue<int, int, iPoint>[] FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].ThirdValue.X - FixX[i].ThirdValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].ThirdValue.Y - FixX[i].ThirdValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].ThirdValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].ThirdValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, Source, FixX[i].ThirdValue, FixX[i + 1].ThirdValue, dU, dV);
                        }

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].ThirdValue.X - FixX[i].ThirdValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].ThirdValue.Y - FixX[i].ThirdValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].ThirdValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].ThirdValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, Source, FixX[i].ThirdValue, FixX[i + 1].ThirdValue, dU, dV);
                        }

                        iMinY++;
                    }
                }
            }
            #endregion

            #region エイリアシング
            else
            {
                PluralsValue<int, iPoint>[] FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].SecondValue.X - FixX[i].SecondValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].SecondValue.Y - FixX[i].SecondValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].SecondValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].SecondValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.DrawXLine(FixX[i].FirstValue.Clipping(0, iMaxX).iPart(), FixX[i + 1].FirstValue.Clipping(0, iMaxX).iPart(), iMinY, Source, FixX[i].SecondValue, FixX[i + 1].SecondValue, dU, dV);
                        }

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].SecondValue.X - FixX[i].SecondValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].SecondValue.Y - FixX[i].SecondValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].SecondValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].SecondValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.CopyXLine(FixX[i].FirstValue.Clipping(0, iMaxX).iPart(), FixX[i + 1].FirstValue.Clipping(0, iMaxX).iPart(), iMinY, Source, FixX[i].SecondValue, FixX[i + 1].SecondValue, dU, dV);
                        }

                        iMinY++;
                    }
                }
            }
            #endregion
        }

        /// <summary>テクスチャマッピングをする</summary>
        /// <param name="Source">描画するテクスチャ</param>
        /// <param name="DestPoints">描画場所を指定したPointRect</param>
        /// <param name="SrcRect">描画するテクスチャの参照範囲</param>
        /// <param name="SmoothingMode">描画時の品質</param>
        /// <param name="CompositingMode">上塗りの方法</param>
        /// <remarks>注意
        /// <para>指定したDestPointsが形作る四角形に180°を超える角度が入ってきた場合テクスチャが不連続になる事があります。</para></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">DestPointsの点の数が4つではない場合に発生</exception>
        public void TextureMapping(CustomWriteableBitmap Source, Point[] DestPoints, Rect SrcRect, SmoothingMode SmoothingMode, CompositingMode CompositingMode)
        {
            if (DestPoints.Length != 4)
                throw new ArgumentOutOfRangeException("DestPoints", "DestPointsの点の数が4つではありません。");

            if (SrcRect.X < 0) SrcRect.X = 0;
            if (SrcRect.Y < 0) SrcRect.Y = 0;
            if (SrcRect.Width >= Source.PixelWidth) SrcRect.Width = Source.PixelWidth - 1;
            if (SrcRect.Height >= Source.PixelHeight) SrcRect.Height = Source.PixelHeight - 1;
            if (SrcRect.Right >= Source.PixelWidth) SrcRect.Width = Source.PixelWidth - SrcRect.X - 1;
            if (SrcRect.Bottom >= Source.PixelHeight) SrcRect.Height = Source.PixelHeight - SrcRect.Y - 1;

            Point[] SrcPoints = new Point[] { new Point(SrcRect.Left, SrcRect.Top), new Point(SrcRect.Right, SrcRect.Top), new Point(SrcRect.Right, SrcRect.Bottom), new Point(SrcRect.Left, SrcRect.Bottom) };

            double MinY = DestPoints[0].Y;
            double MaxY = DestPoints[0].Y;

            for (int i = 1; i < 4; i++)
            {
                if (MinY > DestPoints[i].Y) MinY = DestPoints[i].Y;
                if (MaxY < DestPoints[i].Y) MaxY = DestPoints[i].Y;
            }

            ExtraClass.Clipping(ref MinY, 0, this.LimitSize.Height - 1);
            ExtraClass.Clipping(ref MaxY, 0, this.LimitSize.Height - 1);

            FixLine[,] SideList = new FixLine[2, 4];
            int tmp;
            for (int i = 0; i < 4; i++)
            {
                tmp = i + 1; if (tmp >= 4) tmp = 0;
                SideList[0, i] = FixLine.FromXLine(DestPoints[i], DestPoints[tmp], FixPointConstants.FixX);
                SideList[1, i] = FixLine.FromXLine(SrcPoints[i], SrcPoints[tmp], FixPointConstants.FixBoth);
            }

            FixLineImageCalc Calc = new FixLineImageCalc(SideList);

            int iMinY, iMaxY;
            iMinY = (int)Math.Floor(MinY).MinClipping(0);
            iMaxY = ((int)Math.Ceiling(MaxY)).MaxClipping(this.LimitSize.Height);
            int iMaxX = this.LimitSize.Width.ToFix();

            int dU = 0, dV = 0;

            #region アンチエイリアシング
            if (SmoothingMode == SmoothingMode.AntiAlias)
            {
                PluralsValue<int, int, iPoint>[] FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].ThirdValue.X - FixX[i].ThirdValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].ThirdValue.Y - FixX[i].ThirdValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].ThirdValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].ThirdValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.DrawXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, Source, FixX[i].ThirdValue, FixX[i + 1].ThirdValue, dU, dV);
                        }

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLineAA(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].ThirdValue.X - FixX[i].ThirdValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].ThirdValue.Y - FixX[i].ThirdValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].ThirdValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].ThirdValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.CopyXLineAA(FixX[i].FirstValue.Clipping(0, iMaxX), FixX[i + 1].FirstValue.Clipping(0, iMaxX), FixX[i].SecondValue, FixX[i + 1].SecondValue, iMinY, Source, FixX[i].ThirdValue, FixX[i + 1].ThirdValue, dU, dV);
                        }

                        iMinY++;
                    }
                }
            }
            #endregion

            #region エイリアシング
            else
            {
                PluralsValue<int, iPoint>[] FixX;

                if (CompositingMode == CompositingMode.SourceOver)
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].SecondValue.X - FixX[i].SecondValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].SecondValue.Y - FixX[i].SecondValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].SecondValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].SecondValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.DrawXLine(FixX[i].FirstValue.Clipping(0, iMaxX).iPart(), FixX[i + 1].FirstValue.Clipping(0, iMaxX).iPart(), iMinY, Source, FixX[i].SecondValue, FixX[i + 1].SecondValue, dU, dV);
                        }

                        iMinY++;
                    }
                }

                else
                {
                    while (iMinY != iMaxY)
                    {
                        FixX = Calc.NowLine(iMinY);

                        for (int i = 0; i < FixX.Length; i += 2)
                        {
                            if (FixX[i + 1].FirstValue.iPart() != FixX[i].FirstValue.iPart())
                            {
                                dU = (FixX[i + 1].SecondValue.X - FixX[i].SecondValue.X) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());
                                dV = (FixX[i + 1].SecondValue.Y - FixX[i].SecondValue.Y) / (FixX[i + 1].FirstValue.iPart() - FixX[i].FirstValue.iPart());

                                if (FixX[i].FirstValue < 0)
                                {
                                    FixX[i].SecondValue.X += dU * -FixX[i].FirstValue.iPart();
                                    FixX[i].SecondValue.Y += dV * -FixX[i].FirstValue.iPart();
                                }
                            }

                            this.CopyXLine(FixX[i].FirstValue.Clipping(0, iMaxX).iPart(), FixX[i + 1].FirstValue.Clipping(0, iMaxX).iPart(), iMinY, Source, FixX[i].SecondValue, FixX[i + 1].SecondValue, dU, dV);
                        }

                        iMinY++;
                    }
                }
            }
            #endregion
        }
        #endregion

        #endregion

        #region その他のイメージ操作メソッド
        /// <summary>指定した色を透明色に変えたものを作成して返す</summary>
        /// <param name="TransparentColor">透明色に変える色</param>
        /// <returns>指定色を透明色に変えた後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateTransparent(Color TransparentColor)
        {
            WriteableBitmap bmp = new WriteableBitmap(this.Target);
            int TC = TransparentColor.ToArgb();

            for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
            {
                for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                {
                    if (this.Target.Pixels[this.Index[i, j]] == TC)
                        bmp.Pixels[this.Index[i, j]] = 0;
                }
            }
            
            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>指定した色を別の色に変えたものを作成して返す</summary>
        /// <param name="ChangeColor">別の色に変える指定色</param>
        /// <param name="MakeColor">変えた後の指定色</param>
        /// <returns>指定色を別の色に変えた後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateColor(Color ChangeColor, Color MakeColor)
        {
            WriteableBitmap bmp = new WriteableBitmap(this.Target);
            int TC = ChangeColor.ToArgb();
            int MC = MakeColor.ToArgb();

            for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
            {
                for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                {
                    if (this.Target.Pixels[this.Index[i, j]] == TC)
                        bmp.Pixels[this.Index[i, j]] = MC;
                }
            }

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>全てのピクセルに対して不透明度を割合的に設定作成して返す</summary>
        /// <param name="Ratio">不透明度の割合(255でそのまま0で全てを透明)</param>
        /// <returns>不透明度を設定した後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateRatioOpacity(byte Ratio)
        {
            WriteableBitmap bmp = new WriteableBitmap(this.Target);

            if (Ratio != 0xFF)
            {
                for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
                {
                    for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                        bmp.Pixels[this.Index[i, j]] = this.Target.Pixels[this.Index[i, j]].NewBlendArgb(Ratio);
                }
            }

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>全てのピクセルに対して各要素を割合的に設定・作成して返す</summary>
        /// <param name="Ratio">各要素の割合(255でそのまま0で全てを透明)</param>
        /// <returns>各要素を設定した後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateRatioPixelElements(byte Ratio)
        {
            WriteableBitmap bmp = new WriteableBitmap(this.Target);

            if (Ratio != 0xFF)
            {
                for (int i = this.Rect.Top; i < this.Rect.Bottom; i++)
                {
                    for (int j = this.Rect.Left; j < this.Rect.Right; j++)
                        bmp.Pixels[this.Index[i, j]] = this.Target.Pixels[this.Index[i, j]].NewBlendArgb(Ratio).CalcAlphaBlendToArgb();
                }
            }

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }


        /// <summary>初期指定した範囲を波状に変化させたものを作成して返す</summary>
        /// <param name="RX1">横波のX方向にずらす幅</param>
        /// <param name="RY1">横波のY方向にずらす幅</param>
        /// <param name="XWave1">横波のX方向の波の数</param>
        /// <param name="YWave1">横波のY方向の波の数</param>
        /// <param name="t1">横波の位相</param>
        /// <param name="RX2">縦波のX方向にずらす幅</param>
        /// <param name="RY2">縦波のY方向にずらす幅</param>
        /// <param name="XWave2">縦波のX方向の波の数</param>
        /// <param name="YWave2">縦波のY方向の波の数</param>
        /// <param name="t2">縦波の位相</param>
        /// <returns>波状に変化させた後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateWave(double RX1, double RY1, double XWave1, double YWave1, double t1, double RX2, double RY2, double XWave2, double YWave2, double t2)
        {
            int[] dxtbl1 = new int[this.LimitSize.Height];
            int[] dxtbl2 = new int[this.LimitSize.Width];
            int[] dytbl1 = new int[this.LimitSize.Width];
            int[] dytbl2 = new int[this.LimitSize.Height];
            int[] tmp = new int[this.Target.Pixels.Length];
            WriteableBitmap bmp = new WriteableBitmap(this.LimitSize.Width, this.LimitSize.Height);

            #region 波のテーブル設定
            for (int i = this.Rect.Left; i < this.Rect.Right; i++)
            {
                double rad = (double)(i - this.Rect.Left) / this.Rect.Width * Math.PI;
                dytbl1[i] = (RY1 * Math.Cos(YWave1 * (t1 + rad))).ToFix();
                dxtbl2[i] = (RY2 * Math.Cos(YWave2 * (t2 + rad))).ToFix();
            }

            for (int j = this.Rect.Top; j < this.Rect.Bottom; j++)
            {
                double rad = (double)(j - this.Rect.Top) / this.Rect.Height * Math.PI;
                dxtbl1[j] = (RX1 * Math.Cos(XWave1 * (t1 + rad))).ToFix();
                dytbl2[j] = (RX2 * Math.Cos(XWave2 * (t2 + rad))).ToFix();
            }
            #endregion

            #region 波の計算と書き込み
            for (int j = this.Rect.Top; j < this.Rect.Bottom; j++)
            {
                for (int i = this.Rect.Left; i < this.Rect.Right; i++)
                {
                    int dx = (dxtbl1[j] + dxtbl2[i]).iPart();
                    int dy = (dytbl1[i] + dytbl2[j]).iPart();

                    int x = i + dx;
                    int y = j + dy;

                    if (x < this.Rect.Left) x += this.Rect.Width;
                    if (y < this.Rect.Top) y += this.Rect.Height;
                    if (x >= this.Rect.Right) x -= this.Rect.Width;
                    if (y >= this.Rect.Bottom) y -= this.Rect.Height;

                    tmp[this.Index[j, i]] = this.GetPixel(x, y);
                }
            }

            Array.Copy(tmp, bmp.Pixels, tmp.Length);
            #endregion

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>指定した範囲を波状に変化させたものを作成して返す</summary>
        /// <param name="RX1">横波のX方向にずらす幅</param>
        /// <param name="RY1">横波のY方向にずらす幅</param>
        /// <param name="XWave1">横波のX方向の波の数</param>
        /// <param name="YWave1">横波のY方向の波の数</param>
        /// <param name="t1">横波の位相</param>
        /// <param name="RX2">縦波のX方向にずらす幅</param>
        /// <param name="RY2">縦波のY方向にずらす幅</param>
        /// <param name="XWave2">縦波のX方向の波の数</param>
        /// <param name="YWave2">縦波のY方向の波の数</param>
        /// <param name="t2">縦波の位相</param>
        /// <param name="Rect">波状に変化させたい範囲</param>
        /// <returns>波状に変化させた後のCustomWriteableBitmap</returns>
        public CustomWriteableBitmap CreateWave(double RX1, double RY1, double XWave1, double YWave1, double t1, double RX2, double RY2, double XWave2, double YWave2, double t2, iRect Rect)
        {
            int[] dxtbl1 = new int[this.LimitSize.Height];
            int[] dxtbl2 = new int[this.LimitSize.Width];
            int[] dytbl1 = new int[this.LimitSize.Width];
            int[] dytbl2 = new int[this.LimitSize.Height];
            int[] tmp = new int[this.Target.Pixels.Length];
            WriteableBitmap bmp = new WriteableBitmap(this.LimitSize.Width, this.LimitSize.Height);

            #region 波のテーブル設定
            for (int i = Rect.Left; i < Rect.Right; i++)
            {
                double rad = (double)(i - Rect.Left) / Rect.Width * Math.PI;
                dytbl1[i] = (RY1 * Math.Cos(YWave1 * (t1 + rad))).ToFix();
                dxtbl2[i] = (RY2 * Math.Cos(YWave2 * (t2 + rad))).ToFix();
            }

            for (int j = Rect.Top; j < Rect.Bottom; j++)
            {
                double rad = (double)(j - Rect.Top) / Rect.Height * Math.PI;
                dxtbl1[j] = (RX1 * Math.Cos(XWave1 * (t1 + rad))).ToFix();
                dytbl2[j] = (RX2 * Math.Cos(XWave2 * (t2 + rad))).ToFix();
            }
            #endregion

            #region 波の計算と書き込み
            for (int j = Rect.Top; j < Rect.Bottom; j++)
            {
                for (int i = Rect.Left; i < Rect.Right; i++)
                {
                    int dx = (dxtbl1[j] + dxtbl2[i]).iPart();
                    int dy = (dytbl1[i] + dytbl2[j]).iPart();

                    int x = i + dx;
                    int y = j + dy;

                    if (x < Rect.Left) x += Rect.Width;
                    if (y < Rect.Top) y += Rect.Height;
                    if (x >= Rect.Right) x -= Rect.Width;
                    if (y >= Rect.Bottom) y -= Rect.Height;

                    tmp[this.Index[j, i]] = this.GetPixel(x, y);
                }
            }

            Array.Copy(tmp, bmp.Pixels, tmp.Length);
            #endregion

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>初期指定した範囲にガウス暈しを掛けたものを作成して返す</summary>
        /// <param name="AR">分布の広がり(暈しの度合い)</param>
        /// <returns>ガウス暈しを掛けた後のCustomWriteableBitmap</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">ARの値が1/3未満の場合に発生</exception>
        public CustomWriteableBitmap GaussBlur(double AR)
        {
            int range = (int)(AR * 3);

            if (range < 1)
                throw new ArgumentOutOfRangeException("AR", "ARの値は1/3以上でなければなりません。");

            int[] gausstbl = new int[range + 1];
            int[] tmp = new int[this.Target.Pixels.Length];
            WriteableBitmap bmp = new WriteableBitmap(this.Target);

            for (int m = 0; m < range; m++)
                gausstbl[m] = Math.Exp(-(m * m) / (2.0 * AR * AR)).ToFix(6);

            #region X方向のぼかし
            for (int j = this.Rect.Top; j < this.Rect.Bottom; j++)
            {
                for (int i = this.Rect.Left; i < this.Rect.Right; i++)
                {
                    int a, r, g, b, count;
                    Color ARGB = default(Color);
                    a = r = g = b = count = 0;

                    for (int m = -range; m <= range; m++)
                    {
                        ARGB = this.GetPixel((i + m).Clipping(this.Rect.Left, this.Rect.Right - 1), j).ToColor();

                        int gauss = gausstbl[Math.Abs(m)];
                        a += gauss * ARGB.A;
                        r += gauss * ARGB.R * ARGB.A;
                        g += gauss * ARGB.G * ARGB.A;
                        b += gauss * ARGB.B * ARGB.A;
                        count += gauss;
                    }

                    if (a != 0)
                    {
                        ARGB.A = (byte)(a / count);
                        ARGB.R = (byte)(r / a);
                        ARGB.G = (byte)(g / a);
                        ARGB.B = (byte)(b / a);
                    }

                    else
                        ARGB = default(Color);

                    tmp[this.Index[j, i]] = ARGB.ToArgb();
                }
            }
            #endregion

            #region Y方向のぼかし
            for (int j = this.Rect.Top; j < this.Rect.Bottom; j++)
            {
                for (int i = this.Rect.Left; i < this.Rect.Right; i++)
                {
                    int a, r, g, b, count;
                    Color ARGB = default(Color);
                    a = r = g = b = count = 0;

                    for (int m = -range; m <= range; m++)
                    {
                        ARGB = tmp[this.Index[(j + m).Clipping(this.Rect.Top, this.Rect.Bottom - 1), i]].ToColor();

                        int gauss = gausstbl[Math.Abs(m)];
                        a += gauss * ARGB.A;
                        r += gauss * ARGB.R * ARGB.A;
                        g += gauss * ARGB.G * ARGB.A;
                        b += gauss * ARGB.B * ARGB.A;
                        count += gauss;
                    }

                    if (a != 0)
                    {
                        ARGB.A = (byte)(a / count);
                        ARGB.R = (byte)(r / a);
                        ARGB.G = (byte)(g / a);
                        ARGB.B = (byte)(b / a);
                    }

                    else
                        ARGB = default(Color);

                    bmp.Pixels[this.Index[j, i]] = ARGB.ToArgb();
                }
            }
            #endregion

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>指定した範囲にガウス暈しを掛けたものを作成して返す</summary>
        /// <param name="AR">分布の広がり(暈しの度合い)</param>
        /// <param name="Rect">ガウス暈しを掛けたい範囲</param>
        /// <returns>ガウス暈しを掛けた後のCustomWriteableBitmap</returns>
        /// <exception cref="System.ArgumentOutOfRangeException">ARの値が1/3未満の場合に発生</exception>
        public CustomWriteableBitmap GaussBlur(double AR, iRect Rect)
        {
            int range = (int)(AR * 3);

            if (range < 1)
                throw new ArgumentOutOfRangeException("AR", "ARの値は1/3以上でなければなりません。");

            int[] gausstbl = new int[range + 1];
            int[] tmp = new int[this.Target.Pixels.Length];
            WriteableBitmap bmp = new WriteableBitmap(this.Target);

            for (int m = 0; m < range; m++)
                gausstbl[m] = Math.Exp(-(m * m) / (2.0 * AR * AR)).ToFix(6);

            #region X方向のぼかし
            for (int j = Rect.Top; j < Rect.Bottom; j++)
            {
                for (int i = Rect.Left; i < Rect.Right; i++)
                {
                    int a, r, g, b, count;
                    Color ARGB = default(Color);
                    a = r = g = b = count = 0;

                    for (int m = -range; m <= range; m++)
                    {
                        ARGB = this.GetPixel((i + m).Clipping(Rect.Left, Rect.Right - 1), j).ToColor();

                        int gauss = gausstbl[Math.Abs(m)];
                        a += gauss * ARGB.A;
                        r += gauss * ARGB.R * ARGB.A;
                        g += gauss * ARGB.G * ARGB.A;
                        b += gauss * ARGB.B * ARGB.A;
                        count += gauss;
                    }

                    if (a != 0)
                    {
                        ARGB.A = (byte)(a / count);
                        ARGB.R = (byte)(r / a);
                        ARGB.G = (byte)(g / a);
                        ARGB.B = (byte)(b / a);
                    }

                    else
                        ARGB = default(Color);

                    tmp[this.Index[j, i]] = ARGB.ToArgb();
                }
            }
            #endregion

            #region Y方向のぼかし
            for (int j = Rect.Top; j < Rect.Bottom; j++)
            {
                for (int i = Rect.Left; i < Rect.Right; i++)
                {
                    int a, r, g, b, count;
                    Color ARGB = default(Color);
                    a = r = g = b = count = 0;

                    for (int m = -range; m <= range; m++)
                    {
                        ARGB = tmp[this.Index[(j + m).Clipping(Rect.Top, Rect.Bottom - 1), i]].ToColor();

                        int gauss = gausstbl[Math.Abs(m)];
                        a += gauss * ARGB.A;
                        r += gauss * ARGB.R * ARGB.A;
                        g += gauss * ARGB.G * ARGB.A;
                        b += gauss * ARGB.B * ARGB.A;
                        count += gauss;
                    }

                    if (a != 0)
                    {
                        ARGB.A = (byte)(a / count);
                        ARGB.R = (byte)(r / a);
                        ARGB.G = (byte)(g / a);
                        ARGB.B = (byte)(b / a);
                    }

                    else
                        ARGB = default(Color);

                    bmp.Pixels[this.Index[j, i]] = ARGB.ToArgb();
                }
            }
            #endregion

            return new CustomWriteableBitmap(bmp, (int[,])this.Index.Clone(), this.Rect, this.PColor);
        }

        /// <summary>イメージを指定された通りに回転・反転したものを作成して返す</summary>
        /// <param name="Type">回転・反転方法</param>
        /// <returns>回転・反転した後のCustomWriteableBitmap</returns>
        /// <remarks>注意
        /// <para>反転にはコストは殆ど掛かりませんが、回転にはコストが掛かるので注意してください。</para></remarks>
        public CustomWriteableBitmap RotateFlip(RotateFlipType Type)
        {
            WriteableBitmap bmp = null;
            int[,] Index = null;
            int[] tmp;
            iRect Rect;
            int x, y;

            if (Type <= RotateFlipType.RotateNoneFlipY)
            {
                Index = (int[,])this.Index.Clone();
                Rect = this.Rect;
            }

            else
            {
                Index = new int[this.LimitSize.Width, this.LimitSize.Height];
                Array.Copy(this.Index, Index, this.Index.Length);
                Rect = new iRect(new iPoint(this.Rect.Top, this.Rect.Left), new iPoint(this.Rect.Bottom, this.Rect.Right));
            }

            #region 回転と反転
            switch (Type)
            {
                case RotateFlipType.RotateNoneFlipNone:
                    bmp = new WriteableBitmap(this.Target);
                    break;

                case RotateFlipType.RotateNoneFlipXY:
                    bmp = new WriteableBitmap(this.LimitSize.Width, this.LimitSize.Height);
                    tmp = this.Target.Pixels.Reverse().ToArray();
                    tmp.CopyTo(bmp.Pixels, 0);
                    break;

                case RotateFlipType.RotateNoneFlipX:
                    bmp = new WriteableBitmap(this.LimitSize.Width, this.LimitSize.Height);
                    tmp = bmp.Pixels;
                    x = bmp.PixelWidth - 1;
                    for (int i = 0; i < bmp.PixelHeight; i++)
                    {
                        int[] iArray = new int[bmp.PixelWidth >> 1];
                        Array.Copy(this.Target.Pixels, this.Index[i, 0], iArray, 0, iArray.Length);
                        Array.Copy(iArray.Reverse().ToArray(), 0, tmp, this.Index[i, x - iArray.Length], iArray.Length);

                        Array.Copy(this.Target.Pixels, this.Index[i, x - iArray.Length], iArray, 0, iArray.Length);
                        Array.Copy(iArray.Reverse().ToArray(), 0, tmp, this.Index[i, 0], iArray.Length);
                    }
                    break;

                case RotateFlipType.RotateNoneFlipY:
                    bmp = new WriteableBitmap(this.LimitSize.Width, this.LimitSize.Height);
                    tmp = this.Target.Pixels.Reverse().ToArray();
                    x = bmp.PixelWidth - 1;
                    for (int i = 0; i < bmp.PixelHeight; i++)
                    {
                        int[] iArray = new int[bmp.PixelWidth >> 1];
                        Array.Copy(tmp, this.Index[i, 0], iArray, 0, iArray.Length);
                        Array.Copy(iArray.Reverse().ToArray(), 0, bmp.Pixels, this.Index[i, x - iArray.Length], iArray.Length);

                        Array.Copy(tmp, this.Index[i, x - iArray.Length], iArray, 0, iArray.Length);
                        Array.Copy(iArray.Reverse().ToArray(), 0, bmp.Pixels, this.Index[i, 0], iArray.Length);
                    }
                    break;

                case RotateFlipType.Rotate90FlipNone:
                    bmp = new WriteableBitmap(this.LimitSize.Height, this.LimitSize.Width);
                    tmp = bmp.Pixels;
                    x = bmp.PixelWidth - 1;
                    for (int i = 0; i < this.LimitSize.Height; i++)
                    {
                        for (int j = 0; j < this.LimitSize.Width; j++)
                            tmp[Index[j, x - i]] = this.Target.Pixels[this.Index[i, j]];
                    }
                    break;

                case RotateFlipType.Rotate90FlipXY:
                    bmp = new WriteableBitmap(this.LimitSize.Height, this.LimitSize.Width);
                    tmp = bmp.Pixels;
                    y = bmp.PixelHeight - 1;
                    for (int i = 0; i < this.LimitSize.Height; i++)
                    {
                        for (int j = 0; j < this.LimitSize.Width; j++)
                            tmp[Index[y - j, i]] = this.Target.Pixels[this.Index[i, j]];
                    }
                    break;

                case RotateFlipType.Rotate90FlipX:
                    bmp = new WriteableBitmap(this.LimitSize.Height, this.LimitSize.Width);
                    tmp = bmp.Pixels;
                    for (int i = 0; i < this.LimitSize.Height; i++)
                    {
                        for (int j = 0; j < this.LimitSize.Width; j++)
                            tmp[Index[j, i]] = this.Target.Pixels[this.Index[i, j]];
                    }
                    break;

                case RotateFlipType.Rotate90FlipY:
                    bmp = new WriteableBitmap(this.LimitSize.Height, this.LimitSize.Width);
                    tmp = bmp.Pixels;
                    x = bmp.PixelWidth - 1;
                    y = bmp.PixelHeight - 1;
                    for (int i = 0; i < this.LimitSize.Height; i++)
                    {
                        for (int j = 0; j < this.LimitSize.Width; j++)
                            tmp[Index[y - j, x - i]] = this.Target.Pixels[this.Index[i, j]];
                    }
                    break;

                default:
                    bmp = new WriteableBitmap(this.Target);
                    break;
            }
            #endregion

            return new CustomWriteableBitmap(bmp, Index, Rect, this.PColor);
        }
        #endregion
    }
    #endregion

    #region CreateVectorクラス
    /// <summary>SilverlightのShapeコントロールなどを生成するクラス</summary>
    public class CreateVector
    {
        #region 隠蔽メソッド
        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的Equals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return Object.Equals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的ReferenceEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return Object.ReferenceEquals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetType</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Type GetType()
        {
            return base.GetType();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetHashCode</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのToString</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        }
        #endregion

        #region パラメータセットメソッド
        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        private void SetShapeParameter(Shape Obj, Pen DrawPen, Brush FillBrush)
        {
            Obj.Fill = FillBrush;

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        private void SetShapeParameter(Shape Obj, Pen DrawPen)
        {
            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        private void SetShapeParameter(Shape Obj, Pen DrawPen, Brush FillBrush, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Fill = FillBrush;

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        private void SetShapeParameter(Shape Obj, Pen DrawPen, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        private void SetShapeParameter(Shape Obj, Brush FillBrush, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Fill = FillBrush;
        }

        /// <summary>オブジェクトにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいオブジェクト</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        private void SetObjectParameter(UIElement Obj, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);
        }
        #endregion

        #region 生成メソッド

        #region 図形生成メソッド

        #region 線オブジェクト
        /// <summary>直線オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        public Line Line(Pen CreatePen, double X1, double Y1, double X2, double Y2)
        {
            Line line = new Line();
            line.X1 = X1;
            line.Y1 = Y1;
            line.X2 = X2;
            line.Y2 = Y2;

            SetShapeParameter(line, CreatePen);

            return line;
        }

        /// <summary>直線オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        public Line Line(Pen CreatePen, Point Point1, Point Point2)
        {
            Line line = new Line();
            line.X1 = Point1.X;
            line.Y1 = Point1.Y;
            line.X2 = Point2.X;
            line.Y2 = Point2.Y;

            SetShapeParameter(line, CreatePen);

            return line;
        }

        /// <summary>接続された一連の直線オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public Polyline Lines(Pen CreatePen, PointCollection Points)
        {
            Polyline line = new Polyline();
            line.Points = Points;

            SetShapeParameter(line, CreatePen);

            return line;
        }

        /// <summary>3次ベジエ曲線を生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        public Path Bezier(Pen CreatePen, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            Path path = new Path();
            PathGeometry geometry = new PathGeometry();
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Point1;
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Point2;
                        segment.Point2 = Point3;
                        segment.Point3 = Point4;
                        segmentcollection.Add(segment);
                    }
                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            path.Data = geometry;

            SetShapeParameter(path, CreatePen);

            return path;
        }

        /// <summary>連続3次ベジエ曲線を生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        public Path Beziers(Pen CreatePen, Point[] Points)
        {
            if (Points.Length % 3 != 1)
                throw new ArgumentOutOfRangeException("Points", "点の数が 1 + 3n になりません。");

            Path path = new Path();
            PathGeometry geometry = new PathGeometry();
            int cnt = Points.Length / 3;
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Points[0];
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();

                    for (int i = 0; i < cnt; i++)
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Points[i * 3];
                        segment.Point2 = Points[i * 3 + 1];
                        segment.Point3 = Points[i * 3 + 2];
                        segmentcollection.Add(segment);
                    }

                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            path.Data = geometry;

            SetShapeParameter(path, CreatePen);

            return path;
        }
        #endregion

        #region 平面オブジェクト
        /// <summary>長方形オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public Rectangle Rectangle(Pen CreatePen, double Left, double Top, double Width, double Height)
        {
            Rectangle rect = new Rectangle();
            rect.Width = Width;
            rect.Height = Height;

            SetShapeParameter(rect, CreatePen, Left, Top);

            return rect;
        }

        /// <summary>長方形オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        public Rectangle Rectangle(Pen CreatePen, Rect RectParameter)
        {
            Rectangle rect = new Rectangle();
            rect.Width = RectParameter.Width;
            rect.Height = RectParameter.Height;

            SetShapeParameter(rect, CreatePen, RectParameter.Left, RectParameter.Top);

            return rect;
        }

        /// <summary>塗りつぶしの長方形オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        public Rectangle FillRectangle(Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Rectangle rect = new Rectangle();
            rect.Width = Width;
            rect.Height = Height;

            SetShapeParameter(rect,FillBrush, Left, Top);

            return rect;
        }

        /// <summary>塗りつぶしの長方形オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        public Rectangle FillRectangle(Brush FillBrush, Rect RectParameter)
        {
            Rectangle rect = new Rectangle();
            rect.Width = RectParameter.Width;
            rect.Height = RectParameter.Height;

            SetShapeParameter(rect, FillBrush, RectParameter.Left, RectParameter.Top);

            return rect;
        }

        /// <summary>楕円オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public Ellipse Ellipse(Pen CreatePen, double Left, double Top, double Width, double Height)
        {
            Ellipse e = new Ellipse();
            e.Width = Width;
            e.Height = Height;

            SetShapeParameter(e, CreatePen, Left, Top);

            return e;
        }

        /// <summary>楕円オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        public Ellipse Ellipse(Pen CreatePen, Rect RectParameter)
        {
            Ellipse e = new Ellipse();
            e.Width = RectParameter.Width;
            e.Height = RectParameter.Height;

            SetShapeParameter(e, CreatePen, RectParameter.Left, RectParameter.Top);

            return e;
        }

        /// <summary>塗りつぶしの楕円オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        public Ellipse FillEllipse(Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Ellipse e = new Ellipse();
            e.Width = Width;
            e.Height = Height;

            SetShapeParameter(e,FillBrush, Left, Top);

            return e;
        }

        /// <summary>塗りつぶしの楕円オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        public Ellipse FillEllipse(Brush FillBrush, Rect RectParameter)
        {
            Ellipse e = new Ellipse();
            e.Width = RectParameter.Width;
            e.Height = RectParameter.Height;

            SetShapeParameter(e, FillBrush, RectParameter.Left, RectParameter.Top);

            return e;
        }

        /// <summary>多角形オブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public Polygon Polygon(Pen CreatePen, PointCollection Points)
        {
            Polygon p = new Polygon();
            p.Points = Points;

            SetShapeParameter(p, CreatePen);

            return p;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        public Polygon FillPolygon(Brush FillBrush, PointCollection Points)
        {
            Polygon p = new Polygon();
            p.Points = Points;

            p.Fill = FillBrush;

            return p;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを生成する</summary>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public Polygon FillPolygon(Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polygon p = new Polygon();
            p.Points = Points;

            p.Fill = FillBrush;
            p.FillRule = Rule;

            return p;
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        public Polyline Polyline(Pen CreatePen, Brush FillBrush, PointCollection Points)
        {
            Polyline line = new Polyline();
            line.Points = Points;

            SetShapeParameter(line, CreatePen, FillBrush);

            return line;
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを生成する</summary>
        /// <param name="CreatePen">オブジェクトを生成するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        public Polyline Polyline(Pen CreatePen, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polyline line = new Polyline();
            line.Points = Points;

            SetShapeParameter(line, CreatePen, FillBrush);

            line.FillRule = Rule;

            return line;
        }
        #endregion

        #endregion

        #region その他の生成メソッド
        /// <summary>文字列オブジェクトを生成する</summary>
        /// <param name="CreateString">生成したい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Left">文字列の左上端座標X</param>
        /// <param name="Top">文字列の左上端座標Y</param>
        public TextBlock String(String CreateString, Font StringFont, Brush StringBrush, double Left, double Top)
        {
            TextBlock TB = new TextBlock();
            TB.Text = CreateString;

            TB.FontFamily = StringFont.Family;
            TB.FontSize = StringFont.Size;
            TB.FontStyle = StringFont.Style;
            TB.FontWeight = StringFont.Weight;
            TB.FontStretch = FontStretches.Normal;
            TB.Foreground = StringBrush;

            SetObjectParameter(TB, Left, Top);
            
            return TB;
        }

        /// <summary>文字列オブジェクトを生成する</summary>
        /// <param name="CreateString">生成したい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">生成文字列の左上端の座標</param>
        public TextBlock String(String CreateString, Font StringFont, Brush StringBrush, Point Point)
        {
            TextBlock TB = new TextBlock();
            TB.Text = CreateString;

            TB.FontFamily = StringFont.Family;
            TB.FontSize = StringFont.Size;
            TB.FontStyle = StringFont.Style;
            TB.FontWeight = StringFont.Weight;
            TB.FontStretch = FontStretches.Normal;
            TB.Foreground = StringBrush;

            SetObjectParameter(TB, Point.X, Point.Y);

            return TB;
        }

        /// <summary>文字列オブジェクトを生成する</summary>
        /// <param name="CreateString">生成したい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">生成文字列の左上端の座標</param>
        /// <param name="TransformParameter">文字列オブジェクトの変換情報</param>
        public TextBlock String(String CreateString, Font StringFont, Brush StringBrush, Point Point, Transform TransformParameter)
        {
            TextBlock TB = new TextBlock();
            TB.Text = CreateString;

            TB.FontFamily = StringFont.Family;
            TB.FontSize = StringFont.Size;
            TB.FontStyle = StringFont.Style;
            TB.FontWeight = StringFont.Weight;
            TB.FontStretch = FontStretches.Normal;
            TB.Foreground = StringBrush;
            TB.RenderTransform = TransformParameter;

            SetObjectParameter(TB, Point.X, Point.Y);

            return TB;
        }

        /// <summary>イメージオブジェクトを生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        public Image Image(ImageSource CreateImage, double Left, double Top)
        {
            Image img = new Image();
            img.Source = CreateImage;

            img.Stretch = Stretch.Uniform;

            SetObjectParameter(img, Left, Top);

            return img;
        }

        /// <summary>イメージオブジェクトを指定サイズで生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Width">イメージの幅</param>
        /// <param name="Height">イメージの高さ</param>
        public Image Image(ImageSource CreateImage, double Left, double Top, double Width, double Height)
        {
            Image img = new Image();
            img.Source = CreateImage;
            img.Width = Width;
            img.Height = Height;

            img.Stretch = Stretch.Fill;

            SetObjectParameter(img, Left, Top);

            return img;
        }

        /// <summary>イメージオブジェクトを指定サイズで生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        public Image Image(ImageSource CreateImage, Rect RectParameter)
        {
            Image img = new Image();
            img.Source = CreateImage;
            img.Width = RectParameter.Width;
            img.Height = RectParameter.Height;

            img.Stretch = Stretch.Fill;

            SetObjectParameter(img, RectParameter.Left, RectParameter.Top);

            return img;
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        public Image Image(ImageSource CreateImage, Rect RectParameter, double Opacity)
        {
            Image img = new Image();
            img.Source = CreateImage;
            img.Width = RectParameter.Width;
            img.Height = RectParameter.Height;
            img.Opacity = Opacity;

            img.Stretch = Stretch.Fill;

            SetObjectParameter(img, RectParameter.Left, RectParameter.Top);

            return img;
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した変換に準じて生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        public Image Image(ImageSource CreateImage, Rect RectParameter, Transform TransformParameter)
        {
            Image img = new Image();
            img.Source = CreateImage;
            img.Width = RectParameter.Width;
            img.Height = RectParameter.Height;
            img.RenderTransform = TransformParameter;

            img.Stretch = Stretch.Fill;

            SetObjectParameter(img, RectParameter.Left, RectParameter.Top);

            return img;
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で指定した変換に準じて生成する</summary>
        /// <param name="CreateImage">生成したいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        public Image Image(ImageSource CreateImage, Rect RectParameter, Transform TransformParameter, double Opacity)
        {
            Image img = new Image();
            img.Source = CreateImage;
            img.Width = RectParameter.Width;
            img.Height = RectParameter.Height;
            img.RenderTransform = TransformParameter;
            img.Opacity = Opacity;

            img.Stretch = Stretch.Fill;

            SetObjectParameter(img, RectParameter.Left, RectParameter.Top);

            return img;
        }
        #endregion

        #endregion
    }
    #endregion

    #region EditVectorクラス
    /// <summary>SilverlightのShapeコントロールなどを編集するクラス</summary>
    public class EditVector
    {
        /// <summary>指定したIndexからある対象のUIElementを取得するメソッド</summary>
        private Func<int, ObjectType, UIElement> GetUIElement;

        /// <summary>指定したIndexからある対象のUIElementを取得するメソッドを取得・設定する</summary>
        public Func<int, ObjectType, UIElement> GetUIElementMethod
        {
            get { return this.GetUIElement; }
            set { this.GetUIElement = value; }
        }

        #region コンストラクタ・隠蔽メソッド
        /// <summary>コンストラクタ</summary>
        /// <param name="Target">編集処理対象となるUIElementCollection</param>
        public EditVector(UIElementCollection Target)
        {
            this.GetUIElement = (int Index, ObjectType type) =>
                {
                    return Target[Index];
                };
        }

        /// <summary>コンストラクタ</summary>
        /// <param name="Target">編集処理対象となるUIElementを取得するメソッド(UIElement Func(int Index,ObjectType type))</param>
        public EditVector(Func<int, ObjectType, UIElement> Target)
        {
            this.GetUIElement = Target;
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的Equals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return Object.Equals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的ReferenceEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return Object.ReferenceEquals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetType</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Type GetType()
        {
            return base.GetType();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetHashCode</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのToString</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        }
        #endregion

        #region パラメータセットメソッド
        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        internal void SetShapeParameter(Shape Obj, Pen DrawPen, Brush FillBrush)
        {
            Obj.Fill = FillBrush;

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        internal void SetShapeParameter(Shape Obj, Pen DrawPen)
        {
            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        internal void SetShapeParameter(Shape Obj, Pen DrawPen, Brush FillBrush, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Fill = FillBrush;

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="DrawPen">アウトラインを形成するパラメータ集合のペン</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        internal void SetShapeParameter(Shape Obj, Pen DrawPen, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Stroke = DrawPen.Brush;
            Obj.StrokeThickness = DrawPen.Width;
            Obj.StrokeDashArray = DrawPen.DashArray;
            Obj.StrokeDashCap = DrawPen.DashCap;
            Obj.StrokeDashOffset = DrawPen.DashOffset;
            Obj.StrokeStartLineCap = DrawPen.StartCap;
            Obj.StrokeEndLineCap = DrawPen.EndCap;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        internal void SetShapeParameter(Shape Obj, Brush FillBrush)
        {
            Obj.Fill = FillBrush;
        }

        /// <summary>Shapeにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいShape</param>
        /// <param name="FillBrush">塗りつぶしのブラシ</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        internal void SetShapeParameter(Shape Obj, Brush FillBrush, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);

            Obj.Fill = FillBrush;
        }

        /// <summary>オブジェクトにパラメータをセットする</summary>
        /// <param name="Obj">パラメータをセットしたいオブジェクト</param>
        /// <param name="Left">図形の左端座標</param>
        /// <param name="Top">図形の上端座標</param>
        internal void SetObjectParameter(UIElement Obj, double Left, double Top)
        {
            Obj.SetValue(Canvas.LeftProperty, Left);
            Obj.SetValue(Canvas.TopProperty, Top);
        }
        #endregion

        #region 編集メソッド

        #region 図形編集メソッド

        #region 線オブジェクト

        #region Line
        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Line(int Index, Pen EditPen)
        {
            System.Windows.Shapes.Line Target = this.GetUIElement(Index, ObjectType.Line) as Line;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Line(Target, EditPen);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Line(int Index, double X1, double Y1, double X2, double Y2)
        {
            System.Windows.Shapes.Line Target = this.GetUIElement(Index, ObjectType.Line) as Line;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Line(Target, X1, Y1, X2, Y2);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Line(int Index, Pen EditPen, double X1, double Y1, double X2, double Y2)
        {
            System.Windows.Shapes.Line Target = this.GetUIElement(Index, ObjectType.Line) as Line;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Line(Target, EditPen, X1, Y1, X2, Y2);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Line(int Index, Point Point1, Point Point2)
        {
            System.Windows.Shapes.Line Target = this.GetUIElement(Index, ObjectType.Line) as Line;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Line(Target, Point1, Point2);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Line(int Index, Pen EditPen, Point Point1, Point Point2)
        {
            System.Windows.Shapes.Line Target = this.GetUIElement(Index, ObjectType.Line) as Line;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Line(Target, EditPen, Point1, Point2);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Line(Line Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Line(Line Target, double X1, double Y1, double X2, double Y2)
        {
            Target.X1 = X1;
            Target.Y1 = Y1;
            Target.X2 = X2;
            Target.Y2 = Y2;
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X</param>
        /// <param name="Y2">終点Y</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Line(Line Target, Pen EditPen, double X1, double Y1, double X2, double Y2)
        {
            Target.X1 = X1;
            Target.Y1 = Y1;
            Target.X2 = X2;
            Target.Y2 = Y2;

            SetShapeParameter(Target, EditPen);
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Line(Line Target, Point Point1, Point Point2)
        {
            Target.X1 = Point1.X;
            Target.Y1 = Point1.Y;
            Target.X2 = Point2.X;
            Target.Y2 = Point2.Y;
        }

        /// <summary>直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">終点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Line(Line Target, Pen EditPen, Point Point1, Point Point2)
        {
            Target.X1 = Point1.X;
            Target.Y1 = Point1.Y;
            Target.X2 = Point2.X;
            Target.Y2 = Point2.Y;

            SetShapeParameter(Target, EditPen);
        }
        #endregion

        #region Lines
        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Lines(int Index, Pen EditPen)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Lines(Target, EditPen);
        }

        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Lines(int Index, PointCollection Points)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Lines(Target, Points);
        }

        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Lines(int Index, Pen EditPen, PointCollection Points)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Lines(Target, EditPen, Points);
        }

        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Lines(Polyline Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Lines(Polyline Target, PointCollection Points)
        {
            Target.Points = Points;
        }

        /// <summary>接続された一連の直線オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Lines(Polyline Target, Pen EditPen, PointCollection Points)
        {
            Target.Points = Points;

            SetShapeParameter(Target, EditPen);
        }
        #endregion

        #region Bezier
        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Bezier(int Index, Pen EditPen)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Bezier(Target, EditPen);
        }

        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Bezier(int Index, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Bezier(Target, Point1, Point2, Point3, Point4);
        }

        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Bezier(int Index, Pen EditPen, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Bezier(Target, EditPen, Point1, Point2, Point3, Point4);
        }

        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Bezier(Path Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Bezier(Path Target, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            PathGeometry geometry = new PathGeometry();
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Point1;
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Point2;
                        segment.Point2 = Point3;
                        segment.Point3 = Point4;
                        segmentcollection.Add(segment);
                    }
                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            Target.Data = geometry;
        }

        /// <summary>3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Point1">始点</param>
        /// <param name="Point2">制御点1</param>
        /// <param name="Point3">制御点2</param>
        /// <param name="Point4">終点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Bezier(Path Target, Pen EditPen, Point Point1, Point Point2, Point Point3, Point Point4)
        {
            PathGeometry geometry = new PathGeometry();
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Point1;
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Point2;
                        segment.Point2 = Point3;
                        segment.Point3 = Point4;
                        segmentcollection.Add(segment);
                    }
                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            Target.Data = geometry;

            SetShapeParameter(Target, EditPen);
        }
        #endregion

        #region Beziers
        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Beziers(int Index, Pen EditPen)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Beziers(Target, EditPen);
        }

        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Beziers(int Index, Point[] Points)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Beziers(Target, Points);
        }

        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Beziers(int Index, Pen EditPen, Point[] Points)
        {
            Path Target = this.GetUIElement(Index, ObjectType.Path) as Path;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Beziers(Target, EditPen, Points);
        }

        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Beziers(Path Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Beziers(Path Target, Point[] Points)
        {
            if (Points.Length % 3 != 1)
                throw new ArgumentOutOfRangeException("Points", "点の数が 1 + 3n になりません。");

            PathGeometry geometry = new PathGeometry();
            int cnt = Points.Length / 3;
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Points[0];
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();

                    for (int i = 0; i < cnt; i++)
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Points[i * 3];
                        segment.Point2 = Points[i * 3 + 1];
                        segment.Point3 = Points[i * 3 + 2];
                        segmentcollection.Add(segment);
                    }

                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            Target.Data = geometry;
        }

        /// <summary>連続3次ベジエ曲線を編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">始点を含んだベジエ曲線の点配列(点の数は1+3n:nはベジエ曲線の数、最初の1は始点)</param>
        /// <exception cref="System.ArgumentOutOfRangeException">点の数が期待する数(1+3n)にならない場合に発生</exception>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Beziers(Path Target, Pen EditPen, Point[] Points)
        {
            if (Points.Length % 3 != 1)
                throw new ArgumentOutOfRangeException("Points", "点の数が 1 + 3n になりません。");

            PathGeometry geometry = new PathGeometry();
            int cnt = Points.Length / 3;
            {
                PathFigureCollection pfcollection = new PathFigureCollection();
                {
                    PathFigure pf = new PathFigure();
                    pf.StartPoint = Points[0];
                    PathSegmentCollection segmentcollection = new PathSegmentCollection();

                    for (int i = 0; i < cnt; i++)
                    {
                        BezierSegment segment = new BezierSegment();
                        segment.Point1 = Points[i * 3];
                        segment.Point2 = Points[i * 3 + 1];
                        segment.Point3 = Points[i * 3 + 2];
                        segmentcollection.Add(segment);
                    }

                    pf.Segments = segmentcollection;
                    pfcollection.Add(pf);
                }
                geometry.Figures = pfcollection;
            }
            Target.Data = geometry;

            SetShapeParameter(Target, EditPen);
        }
        #endregion

        #endregion

        #region 平面オブジェクト

        #region Rectangle
        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Rectangle(int Index, Pen EditPen)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Rectangle(Target, EditPen);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Rectangle(int Index, double Left, double Top, double Width, double Height)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Rectangle(Target, Left, Top, Width, Height);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Rectangle(int Index, Pen EditPen, double Left, double Top, double Width, double Height)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Rectangle(Target, EditPen, Left, Top, Width, Height);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Rectangle(int Index, Rect RectParameter)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Rectangle(Target, RectParameter);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Rectangle(int Index, Pen EditPen, Rect RectParameter)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Rectangle(Target, EditPen, RectParameter);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Rectangle(Rectangle Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Rectangle(Rectangle Target, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Rectangle(Rectangle Target, Pen EditPen, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetShapeParameter(Target, EditPen, Left, Top);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Rectangle(Rectangle Target, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Rectangle(Rectangle Target, Pen EditPen, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetShapeParameter(Target, EditPen, RectParameter.Left, RectParameter.Top);
        }
        #endregion

        #region FillRectangle
        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillRectangle(int Index, Brush FillBrush)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillRectangle(Target, FillBrush);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillRectangle(int Index, double Left, double Top, double Width, double Height)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillRectangle(Target, Left, Top, Width, Height);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillRectangle(int Index, Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillRectangle(Target, FillBrush, Left, Top, Width, Height);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillRectangle(int Index, Rect RectParameter)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillRectangle(Target, RectParameter);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillRectangle(int Index, Brush FillBrush, Rect RectParameter)
        {
            Rectangle Target = this.GetUIElement(Index, ObjectType.Rectangle) as Rectangle;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillRectangle(Target, FillBrush, RectParameter);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillRectangle(Rectangle Target, Brush FillBrush)
        {
            SetShapeParameter(Target, FillBrush);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillRectangle(Rectangle Target, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">長方形の左上端座標X</param>
        /// <param name="Top">長方形の左上端座標Y</param>
        /// <param name="Width">長方形の幅</param>
        /// <param name="Height">長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillRectangle(Rectangle Target, Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetShapeParameter(Target, FillBrush, Left, Top);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillRectangle(Rectangle Target, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>塗りつぶしの長方形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillRectangle(Rectangle Target, Brush FillBrush, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetShapeParameter(Target, FillBrush, RectParameter.Left, RectParameter.Top);
        }
        #endregion

        #region Ellipse
        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Ellipse(int Index, Pen EditPen)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Ellipse(Target, EditPen);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Ellipse(int Index, double Left, double Top, double Width, double Height)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Ellipse(Target, Left, Top, Width, Height);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Ellipse(int Index, Pen EditPen, double Left, double Top, double Width, double Height)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Ellipse(Target, EditPen, Left, Top, Width, Height);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Ellipse(int Index, Rect RectParameter)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Ellipse(Target, RectParameter);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Ellipse(int Index, Pen EditPen, Rect RectParameter)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Ellipse(Target, EditPen, RectParameter);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Ellipse(Ellipse Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Ellipse(Ellipse Target, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Ellipse(Ellipse Target, Pen EditPen, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetShapeParameter(Target, EditPen, Left, Top);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Ellipse(Ellipse Target, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Ellipse(Ellipse Target, Pen EditPen, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetShapeParameter(Target, EditPen, RectParameter.Left, RectParameter.Top);
        }
        #endregion

        #region FillEllipse
        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillEllipse(int Index, Brush FillBrush)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillEllipse(Target, FillBrush);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillEllipse(int Index, double Left, double Top, double Width, double Height)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillEllipse(Target, Left, Top, Width, Height);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillEllipse(int Index, Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillEllipse(Target, FillBrush, Left, Top, Width, Height);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillEllipse(int Index, Rect RectParameter)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillEllipse(Target, RectParameter);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillEllipse(int Index, Brush FillBrush, Rect RectParameter)
        {
            Ellipse Target = this.GetUIElement(Index, ObjectType.Ellipse) as Ellipse;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillEllipse(Target, FillBrush, RectParameter);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillEllipse(Ellipse Target, Brush FillBrush)
        {
            SetShapeParameter(Target, FillBrush);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillEllipse(Ellipse Target, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Left">楕円を描く長方形の左上端座標X</param>
        /// <param name="Top">楕円を描く長方形の左上端座標Y</param>
        /// <param name="Width">楕円を描く長方形の幅</param>
        /// <param name="Height">楕円を描く長方形の高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillEllipse(Ellipse Target, Brush FillBrush, double Left, double Top, double Width, double Height)
        {
            Target.Width = Width;
            Target.Height = Height;

            SetShapeParameter(Target, FillBrush, Left, Top);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを生成する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillEllipse(Ellipse Target, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>塗りつぶしの楕円オブジェクトを生成する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="RectParameter">楕円を描く長方形のパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillEllipse(Ellipse Target, Brush FillBrush, Rect RectParameter)
        {
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            SetShapeParameter(Target, FillBrush, RectParameter.Left, RectParameter.Top);
        }
        #endregion

        #region Polygon
        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polygon(int Index, Pen EditPen)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polygon(Target, EditPen);
        }

        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polygon(int Index, PointCollection Points)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polygon(Target, Points);
        }

        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polygon(int Index, Pen EditPen, PointCollection Points)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polygon(Target, EditPen, Points);
        }

        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polygon(Polygon Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">多角形を形作る頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polygon(Polygon Target , PointCollection Points)
        {
            Target.Points = Points;
        }

        /// <summary>多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">多角形を形作る頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polygon(Polygon Target, Pen EditPen, PointCollection Points)
        {
            Target.Points = Points;

            SetShapeParameter(Target, EditPen);
        }
        #endregion

        #region FillPolygon
        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, Brush FillBrush)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, FillBrush);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, PointCollection Points)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, Points);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, Brush FillBrush, PointCollection Points)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, FillBrush, Points);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, FillRule Rule)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, Rule);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, PointCollection Points, FillRule Rule)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, Points, Rule);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, Brush FillBrush, FillRule Rule)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, FillBrush, Rule);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void FillPolygon(int Index, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polygon Target = this.GetUIElement(Index, ObjectType.Polygon) as Polygon;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            FillPolygon(Target, FillBrush, Points, Rule);
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, Brush FillBrush)
        {
            Target.Fill = FillBrush;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">多角形を形作る頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, PointCollection Points)
        {
            Target.Points = Points;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, Brush FillBrush, PointCollection Points)
        {
            Target.Points = Points;

            Target.Fill = FillBrush;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, FillRule Rule)
        {
            Target.FillRule = Rule;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;

            Target.FillRule = Rule;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, Brush FillBrush, FillRule Rule)
        {
            Target.Fill = FillBrush;
            Target.FillRule = Rule;
        }

        /// <summary>塗りつぶしの多角形オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">多角形を形作る頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void FillPolygon(Polygon Target, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;

            Target.Fill = FillBrush;
            Target.FillRule = Rule;
        }
        #endregion

        #region Polyline
        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Pen EditPen)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, EditPen);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Brush FillBrush)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, FillBrush);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Pen EditPen, Brush FillBrush)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, EditPen, FillBrush);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, PointCollection Points, FillRule Rule)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, Points, Rule);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, FillBrush, Points, Rule);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Pen EditPen, PointCollection Points, FillRule Rule)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, EditPen, Points, Rule);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Polyline(int Index, Pen EditPen, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Polyline Target = this.GetUIElement(Index, ObjectType.Polyline) as Polyline;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Polyline(Target, EditPen, FillBrush, Points, Rule);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Pen EditPen)
        {
            SetShapeParameter(Target, EditPen);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Brush FillBrush)
        {
            SetShapeParameter(Target, FillBrush);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Pen EditPen, Brush FillBrush)
        {
            SetShapeParameter(Target, EditPen, FillBrush);
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;
            Target.FillRule = Rule;
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;

            SetShapeParameter(Target, FillBrush);

            Target.FillRule = Rule;
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Pen EditPen, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;

            SetShapeParameter(Target, EditPen);

            Target.FillRule = Rule;
        }

        /// <summary>接続された一連の直線オブジェクトとそれに囲まれた塗りつぶしオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditPen">オブジェクトを編集するPen</param>
        /// <param name="FillBrush">塗りつぶすブラシ</param>
        /// <param name="Points">接続された一連の直線を形作る複数の頂点</param>
        /// <param name="Rule">塗りつぶしのルール</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Polyline(Polyline Target, Pen EditPen, Brush FillBrush, PointCollection Points, FillRule Rule)
        {
            Target.Points = Points;

            SetShapeParameter(Target, EditPen, FillBrush);

            Target.FillRule = Rule;
        }
        #endregion

        #endregion

        #endregion

        #region その他の編集メソッド

        #region String
        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, String EditString)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, EditString);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, Point Point)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, Point);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, Font StringFont, Brush StringBrush)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, StringFont, StringBrush);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, String EditString, Point Point)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, EditString, Point);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, String EditString, Font StringFont, Brush StringBrush)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, EditString, StringFont, StringBrush);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, Font StringFont, Brush StringBrush, Point Point)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, StringFont, StringBrush, Point);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, String EditString, Font StringFont, Brush StringBrush, Point Point)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, EditString, StringFont, StringBrush, Point);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <param name="TransformParameter">文字列オブジェクトの変換情報</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void String(int Index, String EditString, Font StringFont, Brush StringBrush, Point Point, Transform TransformParameter)
        {
            TextBlock Target = this.GetUIElement(Index, ObjectType.String) as TextBlock;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            String(Target, EditString, StringFont, StringBrush, Point, TransformParameter);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, String EditString)
        {
            Target.Text = EditString;
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, Point Point)
        {
            SetObjectParameter(Target, Point.X, Point.Y);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, Font StringFont, Brush StringBrush)
        {
            Target.FontFamily = StringFont.Family;
            Target.FontSize = StringFont.Size;
            Target.FontStyle = StringFont.Style;
            Target.FontWeight = StringFont.Weight;
            Target.FontStretch = FontStretches.Normal;
            Target.Foreground = StringBrush;
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, String EditString, Point Point)
        {
            Target.Text = EditString;

            SetObjectParameter(Target, Point.X, Point.Y);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, String EditString, Font StringFont, Brush StringBrush)
        {
            Target.Text = EditString;

            Target.FontFamily = StringFont.Family;
            Target.FontSize = StringFont.Size;
            Target.FontStyle = StringFont.Style;
            Target.FontWeight = StringFont.Weight;
            Target.FontStretch = FontStretches.Normal;
            Target.Foreground = StringBrush;
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, Font StringFont, Brush StringBrush, Point Point)
        {
            Target.FontFamily = StringFont.Family;
            Target.FontSize = StringFont.Size;
            Target.FontStyle = StringFont.Style;
            Target.FontWeight = StringFont.Weight;
            Target.FontStretch = FontStretches.Normal;
            Target.Foreground = StringBrush;

            SetObjectParameter(Target, Point.X, Point.Y);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, String EditString, Font StringFont, Brush StringBrush, Point Point)
        {
            Target.Text = EditString;

            Target.FontFamily = StringFont.Family;
            Target.FontSize = StringFont.Size;
            Target.FontStyle = StringFont.Style;
            Target.FontWeight = StringFont.Weight;
            Target.FontStretch = FontStretches.Normal;
            Target.Foreground = StringBrush;

            SetObjectParameter(Target, Point.X, Point.Y);
        }

        /// <summary>文字列オブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditString">新たにセットしたい文字列</param>
        /// <param name="StringFont">使用するフォント</param>
        /// <param name="StringBrush">文字を書くブラシ</param>
        /// <param name="Point">編集文字列の左上端の座標</param>
        /// <param name="TransformParameter">文字列オブジェクトの変換情報</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void String(TextBlock Target, String EditString, Font StringFont, Brush StringBrush, Point Point, Transform TransformParameter)
        {
            Target.Text = EditString;

            Target.FontFamily = StringFont.Family;
            Target.FontSize = StringFont.Size;
            Target.FontStyle = StringFont.Style;
            Target.FontWeight = StringFont.Weight;
            Target.FontStretch = FontStretches.Normal;
            Target.Foreground = StringBrush;
            Target.RenderTransform = TransformParameter;

            SetObjectParameter(Target, Point.X, Point.Y);
        }
        #endregion

        #region Image
        /// <summary>イメージオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage);
        }

        /// <summary>イメージオブジェクトを編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, double Left, double Top)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, Left, Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Width">イメージの幅</param>
        /// <param name="Height">イメージの高さ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, double Left, double Top, double Width, double Height)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, Left, Top, Width, Height);
        }

        /// <summary>イメージオブジェクトを指定サイズで編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, Rect RectParameter)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, RectParameter);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, Rect RectParameter, double Opacity)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, RectParameter, Opacity);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した変換に準じて編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, Rect RectParameter, Transform TransformParameter)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, RectParameter, TransformParameter);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で指定した変換に準じて編集する</summary>
        /// <param name="Index">編集対象のインデックス</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        /// <exception cref="System.ArgumentOutOfRangeException">指定されたIndexで得たオブジェクトが編集対象の型ではなかった場合に発生</exception>
        public void Image(int Index, ImageSource EditImage, Rect RectParameter, Transform TransformParameter, double Opacity)
        {
            Image Target = this.GetUIElement(Index, ObjectType.Image) as Image;

            if (Target == null) throw new ArgumentOutOfRangeException("Index", "指定されたIndexで得たオブジェクトが編集対象の型ではありません。");

            Image(Target, EditImage, RectParameter, TransformParameter, Opacity);
        }

        /// <summary>イメージオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage)
        {
            Target.Source = EditImage;

            Target.Stretch = Stretch.Uniform;
        }

        /// <summary>イメージオブジェクトを編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, double Left, double Top)
        {
            Target.Source = EditImage;

            Target.Stretch = Stretch.Uniform;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="Left">イメージの左上端座標X</param>
        /// <param name="Top">イメージの左上端座標Y</param>
        /// <param name="Width">イメージの幅</param>
        /// <param name="Height">イメージの高さ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, double Left, double Top, double Width, double Height)
        {
            Target.Source = EditImage;
            Target.Width = Width;
            Target.Height = Height;

            Target.Stretch = Stretch.Fill;

            SetObjectParameter(Target, Left, Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, Rect RectParameter)
        {
            Target.Source = EditImage;
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;

            Target.Stretch = Stretch.Fill;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, Rect RectParameter, double Opacity)
        {
            Target.Source = EditImage;
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;
            Target.Opacity = Opacity;

            Target.Stretch = Stretch.Fill;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した変換に準じて編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, Rect RectParameter, Transform TransformParameter)
        {
            Target.Source = EditImage;
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;
            Target.RenderTransform = TransformParameter;

            Target.Stretch = Stretch.Fill;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }

        /// <summary>イメージオブジェクトを指定サイズで指定した不透明度で指定した変換に準じて編集する</summary>
        /// <param name="Target">編集対象</param>
        /// <param name="EditImage">新たにセットしたいイメージ</param>
        /// <param name="RectParameter">イメージの描画原点とサイズのパラメータ</param>
        /// <param name="TransformParameter">イメージの変換情報</param>
        /// <param name="Opacity">0.0～1.0の範囲の値で表す不透明度</param>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public void Image(Image Target, ImageSource EditImage, Rect RectParameter, Transform TransformParameter, double Opacity)
        {
            Target.Source = EditImage;
            Target.Width = RectParameter.Width;
            Target.Height = RectParameter.Height;
            Target.RenderTransform = TransformParameter;
            Target.Opacity = Opacity;

            Target.Stretch = Stretch.Fill;

            SetObjectParameter(Target, RectParameter.Left, RectParameter.Top);
        }
        #endregion

        #endregion

        #endregion
    }
    #endregion

    #endregion

    #endregion
}
#endregion

#region 汎用性の高いオブジェクトを保有するネームスペース
namespace System.Linq
{
    #region ExtraClassクラス
    /// <summary>拡張メソッドを定義したクラス</summary>
    /// <remarks>注意<para>このクラスの拡張メソッドは速度重視のため殆どエラー処理を行っていません。</para></remarks>
    public static class ExtraClass
    {
        #region Graphics系
        /// <summary>DashStyleを実際に使用できるDoubleCollection型に変換して返す</summary>
        /// <param name="Obj">変換対象のDashStyle</param>
        /// <returns>変換後のDoubleCollection(Solid、Customは中身なし)</returns>
        public static System.Windows.Media.DoubleCollection GetDashArray(this System.NetFramework.DashStyle Obj)
        {
            DoubleCollection DA = new DoubleCollection();

            switch (Obj)
            {
                case DashStyle.Solid:
                    break;

                case DashStyle.Dash:
                    DA.Add(3.0);
                    DA.Add(1.0);
                    break;

                case DashStyle.Dot:
                    DA.Add(1.0);
                    DA.Add(1.0);
                    break;

                case DashStyle.DashDot:
                    DA.Add(3.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    break;

                case DashStyle.DashDotDot:
                    DA.Add(3.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    DA.Add(1.0);
                    break;

                case DashStyle.Custom:
                    break;
            }

            return DA;
        }

        /// <summary>このGraphicsをRasterGraphicsに変換できれば返す(不可能な場合null)</summary>
        /// <param name="Obj">変換したいGraphicsオブジェクト</param>
        /// <returns>RasterGraphicsに変換したGraphics</returns>
        public static System.NetFramework.RasterGraphics Raster(this System.NetFramework.Graphics Obj)
        {
            return Obj as System.NetFramework.RasterGraphics;
        }

        /// <summary>このGraphicsをVectorGraphicsに変換できれば返す(不可能な場合null)</summary>
        /// <param name="Obj">変換したいGraphicsオブジェクト</param>
        /// <returns>VectorGraphicsに変換したGraphics</returns>
        public static System.NetFramework.VectorGraphics Vector(this System.NetFramework.Graphics Obj)
        {
            return Obj as System.NetFramework.VectorGraphics;
        }

        /// <summary>このGraphicsをRVGraphicsに変換できれば返す(不可能な場合null)</summary>
        /// <param name="Obj">変換したいGraphicsオブジェクト</param>
        /// <returns>RVGraphicsに変換したGraphics</returns>
        public static System.NetFramework.RVGraphics RVBoth(this System.NetFramework.Graphics Obj)
        {
            return Obj as System.NetFramework.RVGraphics;
        }

        /// <summary>指定した場所のピクセルを取得する</summary>
        /// <param name="Obj">ピクセル操作をするWriteableBitmap</param>
        /// <param name="Index">取得するピクセルのメモリ位置</param>
        /// <returns>指定されたピクセルを表すColor構造体</returns>
        public static Color GetPixel(this System.Windows.Media.Imaging.WriteableBitmap Obj, int Index)
        {
            return Obj.Pixels[Index].ToColor();
        }

        /// <summary>指定した場所のピクセルを取得する</summary>
        /// <param name="Obj">ピクセル操作をするWriteableBitmap</param>
        /// <param name="X">取得するピクセルのX座標</param>
        /// <param name="Y">取得するピクセルのY座標</param>
        /// <returns>指定されたピクセルを表すColor構造体</returns>
        public static Color GetPixel(this System.Windows.Media.Imaging.WriteableBitmap Obj, int X, int Y)
        {
            return Obj.Pixels[Y * Obj.PixelWidth + X].ToColor();
        }

        /// <summary>指定した場所のピクセルを設定する</summary>
        /// <param name="Obj">ピクセル操作をするWriteableBitmap</param>
        /// <param name="Index">設定するピクセルのメモリ位置</param>
        /// <param name="Color">設定するピクセルを表すColor構造体</param>
        public static void SetPixel(this System.Windows.Media.Imaging.WriteableBitmap Obj, int Index, Color Color)
        {
            Obj.Pixels[Index] = Color.ToArgb();
        }

        /// <summary>指定した場所のピクセルを設定する</summary>
        /// <param name="Obj">ピクセル操作をするWriteableBitmap</param>
        /// <param name="X">設定するピクセルのX座標</param>
        /// <param name="Y">設定するピクセルのY座標</param>
        /// <param name="Color">設定するピクセルを表すColor構造体</param>
        public static void SetPixel(this System.Windows.Media.Imaging.WriteableBitmap Obj, int X, int Y, Color Color)
        {
            Obj.Pixels[Y * Obj.PixelWidth + X] = Color.ToArgb();
        }

        /// <summary>指定した色を透明色する(不可逆変換)</summary>
        /// <param name="Obj">透明色処理をするWriteableBitmap</param>
        /// <param name="TransparentColor">透明色に変える色</param>
        public static void MakeTransparent(this System.Windows.Media.Imaging.WriteableBitmap Obj, Color TransparentColor)
        {
            int TC = TransparentColor.ToArgb();

            for (int i = 0; i < Obj.Pixels.Length; i++)
            {
                if (Obj.Pixels[i] == TC)
                    Obj.Pixels[i] = 0;
            }
        }
        #endregion

        #region 色情報系

        #region 形式・内部情報変換
        /// <summary>ARGB形式の色情報をColorオブジェクトにして返す</summary>
        /// <param name="ARGB">基となるARGB形式の色情報</param>
        /// <returns>Colorオブジェクト</returns>
        public static Color ToColor(this int ARGB)
        {
            return Color.FromArgb((byte)(ARGB >> 24), (byte)(ARGB >> 16), (byte)(ARGB >> 8), (byte)ARGB);
        }

        /// <summary>ColorオブジェクトをARGB形式にして返す</summary>
        /// <param name="Color">基となるColorオブジェクト</param>
        /// <returns>ARGB形式の色情報</returns>
        public static int ToArgb(this System.Windows.Media.Color Color)
        {
            return (Color.A << 24) | (Color.R << 16) | (Color.G << 8) | Color.B;
        }

        /// <summary>byte配列(要素数4)オブジェクトをARGB形式にして返す</summary>
        /// <param name="ARGB">基となるbyte配列</param>
        /// <returns>ARGB形式の色情報</returns>
        public static int ToArgb(this byte[] ARGB)
        {
            return (ARGB[0] << 24) | (ARGB[1] << 16) | (ARGB[2] << 8) | ARGB[3];
        }

        /// <summary>α値を新しく指定してカラー構造体を生成する</summary>
        /// <param name="Color">基となるColorオブジェクト</param>
        /// <param name="Alpha">新たに使うα値</param>
        /// <returns>作成したカラー構造体</returns>
        public static System.Windows.Media.Color NewArgb(this System.Windows.Media.Color Color, byte Alpha)
        {
            Color.A = Alpha;
            return Color;
        }

        /// <summary>α値を新しく指定してARGB形式の色情報を生成する</summary>
        /// <param name="ARGB">基となるARGB形式の色情報</param>
        /// <param name="Alpha">新たに使うα値</param>
        /// <returns>作成したARGB形式の色情報</returns>
        public static int NewArgb(this int ARGB, byte Alpha)
        {
            return (Alpha << 24) | (ARGB & 0xFFFFFF);
        }

        /// <summary>α値を新しく指定してARGB形式の色情報を生成する</summary>
        /// <param name="ARGB">基となるbyte配列の色情報</param>
        /// <param name="Alpha">新たに使うα値</param>
        /// <returns>作成したbyte配列の色情報</returns>
        public static byte[] NewArgb(this byte[] ARGB, byte Alpha)
        {
            byte[] NewARGB = (byte[])ARGB.Clone();
            NewARGB[0] = Alpha;
            return NewARGB;
        }

        /// <summary>α値をOpacityの割合で設定してカラー構造体を生成する</summary>
        /// <param name="Color">基となるColorオブジェクト</param>
        /// <param name="Opacity">α値に掛ける不透明度</param>
        /// <returns>作成したカラー構造体</returns>
        public static System.Windows.Media.Color NewBlendArgb(this System.Windows.Media.Color Color, byte Opacity)
        {
            Color.A = (byte)(Opacity * Color.A >> 8);
            return Color;
        }

        /// <summary>α値をRatioの割合で設定してARGB形式の色情報を生成する</summary>
        /// <param name="ARGB">基となるARGB形式の色情報</param>
        /// <param name="Ratio">α値の割合(255で100％、0で0％)</param>
        /// <returns>作成したARGB形式の色情報</returns>
        public static int NewBlendArgb(this int ARGB, byte Ratio)
        {
            if (Ratio == 0)
                ARGB = ARGB & 0xFFFFFF;

            else if (Ratio != 0xFF)
                ARGB = ((byte)(Ratio * (byte)(ARGB >> 24) >> 8) << 24) | (ARGB & 0xFFFFFF);

            return ARGB;
        }

        /// <summary>α値をOpacityの割合で設定してARGB形式の色情報を生成する</summary>
        /// <param name="ARGB">基となるbyte配列の色情報</param>
        /// <param name="Ratio">α値の割合(255で100％、0で0％)</param>
        /// <returns>作成したbyte配列の色情報</returns>
        public static byte[] NewBlendArgb(this byte[] ARGB, byte Ratio)
        {
            byte[] NewARGB = (byte[])ARGB.Clone();
            NewARGB[0] = (byte)(Ratio * NewARGB[0] >> 8);
            return NewARGB;
        }
        #endregion

        #region αブレンド
        /// <summary>背景色と上塗り色をαブレンドする</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>αブレンド後の色</returns>
        public static int AlphaBlend(this int DestColor, int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (res == 0)
                res = DestColor;

            else if (res == 0xFF || DstA == 0)
                res = SourceColor;

            else if (DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | ((((byte)(SourceColor >> 16) - DstR) * res >> 8) + DstR) << 16
                    | ((((byte)(SourceColor >> 8) - DstG) * res >> 8) + DstG) << 8
                    | (((byte)SourceColor - DstB) * res >> 8) + DstB;
            }

            else
            {
                byte SrcA = (byte)res;
                DstA = (byte)((byte)(~SrcA) * DstA >> 8);

                res = (byte)(SrcA + DstA);

                res = res << 24
                    | ((byte)(SourceColor >> 16) * SrcA + DstR * DstA) / res << 16
                    | ((byte)(SourceColor >> 8) * SrcA + DstG * DstA) / res << 8
                    | ((byte)(SourceColor) * SrcA + DstB * DstA) / res;
            }

            return res.CalcAlphaBlendToArgb();
        }

        /// <summary>背景色と上塗り色を新規にαを指定してαブレンドする</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">上塗り色のα値</param>
        /// <returns>αブレンド後の色</returns>
        public static int AlphaBlend(this int DestColor, int SourceColor, byte Alpha)
        {
            int res;
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (Alpha == 0)
                res = DestColor;

            else if (Alpha == 0xFF || DstA == 0)
                res = (Alpha << 24) | (SourceColor & 0xFFFFFF);

            else if (DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | ((((byte)(SourceColor >> 16) - DstR) * Alpha >> 8) + DstR) << 16
                    | ((((byte)(SourceColor >> 8) - DstG) * Alpha >> 8) + DstG) << 8
                    | (((byte)SourceColor - DstB) * Alpha >> 8) + DstB;
            }

            else
            {
                DstA = (byte)((byte)(~Alpha) * DstA >> 8);

                res = (byte)(Alpha + DstA);

                res = res << 24
                    | ((byte)(SourceColor >> 16) * Alpha + DstR * DstA) / res << 16
                    | ((byte)(SourceColor >> 8) * Alpha + DstG * DstA) / res << 8
                    | ((byte)(SourceColor) * Alpha + DstB * DstA) / res;
            }

            return res.CalcAlphaBlendToArgb();
        }

        /// <summary>背景が無色(#00000000)の時に対してαブレンドする(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>計算済みの上塗り色</returns>
        public static int AlphaBlend(this int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte R = (byte)(SourceColor >> 16);
            byte G = (byte)(SourceColor >> 8);
            byte B = (byte)(SourceColor);

            if (res == 0xFF)
                res = SourceColor;

            else if (res != 0)
            {
                res = res << 24
                    | (R * res >> 8) << 16
                    | (G * res >> 8) << 8
                    | (B * res >> 8);
            }

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対してα値を指定してαブレンドする(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">指定するα値</param>
        /// <returns>計算済みの上塗り色</returns>
        public static int AlphaBlend(this int SourceColor, byte Alpha)
        {
            int res;
            byte R = (byte)(SourceColor >> 16);
            byte G = (byte)(SourceColor >> 8);
            byte B = (byte)(SourceColor);

            if (Alpha == 0)
                res = 0;

            else if (Alpha == 0xFF)
                res = unchecked((int)0xFF000000) | (SourceColor & 0xFFFFFF);

            else
            {
                res = Alpha << 24
                    | (R * Alpha >> 8) << 16
                    | (G * Alpha >> 8) << 8
                    | (B * Alpha >> 8);
            }

            return res;
        }

        /// <summary>背景色と計算済み上塗り色を高速αブレンドする</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SCARGB">計算済みの上塗り色並びはARGB(計算済みはRGBのみ)</param>
        /// <returns>αブレンド後の色</returns>
        public static int QuickAlphaBlend(this int DestColor, byte[] SCARGB)
        {
            int res;
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (SCARGB[0] == 0)
                res = DestColor.CalcAlphaBlendToArgb();

            else if (SCARGB[0] == 0xFF || DstA == 0)
                res = SCARGB[0] << 24 | (SCARGB[1] << 16) | (SCARGB[2] << 8) | SCARGB[3];

            else if (DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | (SCARGB[1] + (DstR * (byte)(~SCARGB[0]) >> 8)) << 16
                    | (SCARGB[2] + (DstG * (byte)(~SCARGB[0]) >> 8)) << 8
                    | SCARGB[3] + (DstB * (byte)(~SCARGB[0]) >> 8);
            }

            else
            {
                DstA = (byte)((byte)(~SCARGB[0]) * DstA >> 8);

                res = (byte)(SCARGB[0] + DstA);

                res = res << 24
                    | (((SCARGB[1] << 8) + DstR * DstA) >> 8) << 16
                    | (((SCARGB[2] << 8) + DstG * DstA) >> 8) << 8
                    | (((SCARGB[3] << 8) + DstB * DstA) >> 8);
            }

            return res;
        }

        /// <summary>高速αブレンドで使用する上塗り色の計算をする(RGB毎にα値の割合に設定する)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>計算済みの上塗り色</returns>
        public static byte[] CalcAlphaBlend(this int SourceColor)
        {
            byte[] ARGB = SourceColor.ToBytes();

            if (ARGB[0] == 0)
                ARGB[1] = ARGB[2] = ARGB[3] = 0;

            else if (ARGB[0] != 0xFF)
            {
                ARGB[1] = (byte)(ARGB[1] * ARGB[0] >> 8);
                ARGB[2] = (byte)(ARGB[2] * ARGB[0] >> 8);
                ARGB[3] = (byte)(ARGB[3] * ARGB[0] >> 8);
            }

            return ARGB;
        }

        /// <summary>高速αブレンドで使用する上塗り色の計算をしてARGB形式にして返す(RGB毎にα値の割合に設定する)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>計算済みの上塗り色</returns>
        public static int CalcAlphaBlendToArgb(this int SourceColor)
        {
            byte Alpha = (byte)(SourceColor >> 24);

            if (Alpha == 0)
                SourceColor = 0;

            else if (Alpha != 0xFF)
            {
                SourceColor = Alpha << 24
                            | ((byte)(SourceColor >> 16) * Alpha >> 8) << 16
                            | ((byte)(SourceColor >> 8) * Alpha >> 8) << 8
                            | (byte)SourceColor * Alpha >> 8;
            }

            return SourceColor;
        }
        #endregion

        #region 加算合成
        /// <summary>背景色と上塗り色を加算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>加算合成後の色</returns>
        public static int AddBlend(this int DestColor, int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (res == 0)
                res = DestColor;

            else if (res == 0xFF && DstA == 0xFF)
            {
                int tmp;
                res = unchecked((int)0xFF000000)
                    | ((tmp = SrcR + DstR) > 0xFF ? 0xFF : tmp) << 16
                    | ((tmp = SrcG + DstG) > 0xFF ? 0xFF : tmp) << 8
                    | ((tmp = SrcB + DstB) > 0xFF ? 0xFF : tmp);
            }

            else
            {
                int tmp;
                res = DstA << 24
                    | (((tmp = (SrcR * res + DstR * DstA) >> 8)) > 0xFF ? 0xFF : tmp) << 16
                    | (((tmp = (SrcG * res + DstG * DstA) >> 8)) > 0xFF ? 0xFF : tmp) << 8
                    | (((tmp = (SrcB * res + DstB * DstA) >> 8)) > 0xFF ? 0xFF : tmp);
            }

            return res;
        }

        /// <summary>背景色と上塗り色を新規にαを指定して加算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">上塗り色のα値</param>
        /// <returns>加算合成後の色</returns>
        public static int AddBlend(this int DestColor, int SourceColor, byte Alpha)
        {
            int res;
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (Alpha == 0)
                res = DestColor;

            else if (Alpha == 0xFF && DstA == 0xFF)
            {
                int tmp;
                res = unchecked((int)0xFF000000)
                    | ((tmp = SrcR + DstR) > 0xFF ? 0xFF : tmp) << 16
                    | ((tmp = SrcG + DstG) > 0xFF ? 0xFF : tmp) << 8
                    | ((tmp = SrcB + DstB) > 0xFF ? 0xFF : tmp);
            }

            else
            {
                int tmp;
                res = DstA << 24
                    | (((tmp = (SrcR * Alpha + DstR * DstA) >> 8)) > 0xFF ? 0xFF : tmp) << 16
                    | (((tmp = (SrcG * Alpha + DstG * DstA) >> 8)) > 0xFF ? 0xFF : tmp) << 8
                    | (((tmp = (SrcB * Alpha + DstB * DstA) >> 8)) > 0xFF ? 0xFF : tmp);
            }

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対して加算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>加算合成後の色</returns>
        public static int AddBlend(this int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);

            res = ((byte)(SourceColor >> 16) * res >> 8) << 16
                | ((byte)(SourceColor >> 8) * res >> 8) << 8
                | ((byte)(SourceColor) * res >> 8);

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対してα値を指定して加算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">指定するα値</param>
        /// <returns>加算合成後の色</returns>
        public static int AddBlend(this int SourceColor, byte Alpha)
        {
            int res = ((byte)(SourceColor >> 16) * Alpha >> 8) << 16
                    | ((byte)(SourceColor >> 8) * Alpha >> 8) << 8
                    | ((byte)(SourceColor) * Alpha >> 8);

            return res;
        }
        #endregion

        #region 減算合成
        /// <summary>背景色と上塗り色を減算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>減算合成後の色</returns>
        public static int SubBlend(this int DestColor, int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (res == 0)
                res = DestColor;

            else if (res == 0xFF && DstA == 0xFF)
            {
                int tmp;
                res = unchecked((int)0xFF000000)
                    | ((tmp = DstR - SrcR) < 0 ? 0 : tmp) << 16
                    | ((tmp = DstG - SrcG) < 0 ? 0 : tmp) << 8
                    | ((tmp = DstB - SrcB) < 0 ? 0 : tmp);
            }

            else
            {
                int tmp;
                res = DstA << 24
                    | ((tmp = (DstR * DstA - SrcR * res) >> 8) < 0 ? 0 : tmp) << 16
                    | ((tmp = (DstG * DstA - SrcG * res) >> 8) < 0 ? 0 : tmp) << 8
                    | ((tmp = (DstB * DstA - SrcB * res) >> 8) < 0 ? 0 : tmp);
            }

            return res;
        }

        /// <summary>背景色と上塗り色を新規にαを指定して減算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">上塗り色のα値</param>
        /// <returns>減算合成後の色</returns>
        public static int SubBlend(this int DestColor, int SourceColor, byte Alpha)
        {
            int res;
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);


            if (Alpha == 0)
                res = DestColor;

            else if (Alpha == 0xFF && DstA == 0xFF)
            {
                int tmp;
                res = unchecked((int)0xFF000000)
                    | ((tmp = DstR - SrcR) < 0 ? 0 : tmp) << 16
                    | ((tmp = DstG - SrcG) < 0 ? 0 : tmp) << 8
                    | ((tmp = DstB - SrcB) < 0 ? 0 : tmp);
            }

            else
            {
                int tmp;
                res = DstA << 24
                    | ((tmp = (DstR * DstA - SrcR * Alpha) >> 8) < 0 ? 0 : tmp) << 16
                    | ((tmp = (DstG * DstA - SrcG * Alpha) >> 8) < 0 ? 0 : tmp) << 8
                    | ((tmp = (DstB * DstA - SrcB * Alpha) >> 8) < 0 ? 0 : tmp);
            }

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対して減算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>減算合成後の色(常に0)</returns>
        public static int SubBlend(this int SourceColor)
        {
            return 0;
        }

        /// <summary>背景が無色(#00000000)の時に対してα値を指定して減算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">指定するα値</param>
        /// <returns>減算合成後の色(常に0)</returns>
        public static int SubBlend(this int SourceColor, byte Alpha)
        {
            return 0;
        }
        #endregion

        #region 乗算合成
        /// <summary>背景色と上塗り色を乗算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>乗算合成後の色</returns>
        public static int MulBlend(this int DestColor, int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (res == 0)
                res = DestColor;

            else if (res == 0xFF && DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | (SrcR * DstR >> 8) << 16
                    | (SrcG * DstG >> 8) << 8
                    | (SrcB * DstB >> 8);
            }

            else
            {
                res = DstA << 24
                    | ((DstR * DstA >> 8) * (0xFF + ((SrcR - 0xFF) * res >> 8)) >> 8) << 16
                    | ((DstG * DstA >> 8) * (0xFF + ((SrcG - 0xFF) * res >> 8)) >> 8) << 8
                    | ((DstB * DstA >> 8) * (0xFF + ((SrcB - 0xFF) * res >> 8)) >> 8);
            }

            return res;
        }

        /// <summary>背景色と上塗り色を新規にαを指定してを乗算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">上塗り色のα値</param>
        /// <returns>乗算合成後の色</returns>
        public static int MulBlend(this int DestColor, int SourceColor, byte Alpha)
        {
            int res;
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (Alpha == 0)
                res = DestColor;

            else if (Alpha == 0xFF && DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | (SrcR * DstR >> 8) << 16
                    | (SrcG * DstG >> 8) << 8
                    | (SrcB * DstB >> 8);
            }

            else
            {
                res = DstA << 24
                    | ((DstR * DstA >> 8) * (0xFF + ((SrcR - 0xFF) * Alpha >> 8)) >> 8) << 16
                    | ((DstG * DstA >> 8) * (0xFF + ((SrcG - 0xFF) * Alpha >> 8)) >> 8) << 8
                    | ((DstB * DstA >> 8) * (0xFF + ((SrcB - 0xFF) * Alpha >> 8)) >> 8);
            }

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対して乗算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>乗算合成後の色(常に0)</returns>
        public static int MulBlend(this int SourceColor)
        {
            return 0;
        }

        /// <summary>背景が無色(#00000000)の時に対してα値を指定して乗算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">指定するα値</param>
        /// <returns>乗算合成後の色(常に0)</returns>
        public static int MulBlend(this int SourceColor, byte Alpha)
        {
            return 0;
        }
        #endregion

        #region 除算合成
        /// <summary>背景色と上塗り色を除算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>除算合成後の色</returns>
        public static int DivBlend(this int DestColor, int SourceColor)
        {
            int res = (byte)(SourceColor >> 24);
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (res == 0)
                res = DestColor;

            else if (res == 0xFF && DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | ((DstR << 8) / (SrcR + 1)) << 16
                    | ((DstG << 8) / (SrcG + 1)) << 8
                    | ((DstB << 8) / (SrcB + 1));
            }

            else
            {
                res = DstA << 24
                    | ((DstR * DstA) / ((0xFF + ((SrcR - 0xFF) * res >> 8)) + 1)) << 16
                    | ((DstG * DstA) / ((0xFF + ((SrcG - 0xFF) * res >> 8)) + 1)) << 8
                    | ((DstB * DstA) / ((0xFF + ((SrcB - 0xFF) * res >> 8)) + 1));
            }

            return res;
        }

        /// <summary>背景色と上塗り色を新規にαを指定してを除算合成する</summary>
        /// <param name="DestColor">背景色</param>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">上塗り色のα値</param>
        /// <returns>除算合成後の色</returns>
        public static int DivBlend(this int DestColor, int SourceColor, byte Alpha)
        {
            int res;
            byte SrcR = (byte)(SourceColor >> 16);
            byte SrcG = (byte)(SourceColor >> 8);
            byte SrcB = (byte)(SourceColor);
            byte DstA = (byte)(DestColor >> 24);
            byte DstR = (byte)(DestColor >> 16);
            byte DstG = (byte)(DestColor >> 8);
            byte DstB = (byte)(DestColor);

            if (Alpha == 0)
                res = DestColor;

            else if (Alpha == 0xFF && DstA == 0xFF)
            {
                res = unchecked((int)0xFF000000)
                    | ((DstR << 8) / (SrcR + 1)) << 16
                    | ((DstG << 8) / (SrcG + 1)) << 8
                    | ((DstB << 8) / (SrcB + 1));
            }

            else
            {
                res = DstA << 24
                    | ((DstR * DstA) / ((0xFF + ((SrcR - 0xFF) * Alpha >> 8)) + 1)) << 16
                    | ((DstG * DstA) / ((0xFF + ((SrcG - 0xFF) * Alpha >> 8)) + 1)) << 8
                    | ((DstB * DstA) / ((0xFF + ((SrcB - 0xFF) * Alpha >> 8)) + 1));
            }

            return res;
        }

        /// <summary>背景が無色(#00000000)の時に対して除算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <returns>除算合成後の色(常に0)</returns>
        public static int DivBlend(this int SourceColor)
        {
            return 0;
        }

        /// <summary>背景が無色(#00000000)の時に対してα値を指定して除算合成する(ソースコピー)</summary>
        /// <param name="SourceColor">上塗り色</param>
        /// <param name="Alpha">指定するα値</param>
        /// <returns>除算合成後の色(常に0)</returns>
        public static int DivBlend(this int SourceColor, byte Alpha)
        {
            return 0;
        }
        #endregion

        #endregion

        #region 固定小数系
        /// <summary>浮動小数を固定小数(16:16)に変換する</summary>
        /// <param name="Obj">基となる浮動小数</param>
        /// <returns>固定小数(16:16)</returns>
        public static int ToFix(this float Obj)
        {
            return (int)(Obj * 0x10000);
        }

        /// <summary>浮動小数を固定小数(16:16)に変換する</summary>
        /// <param name="Obj">基となる浮動小数</param>
        /// <returns>固定小数(16:16)</returns>
        public static int ToFix(this double Obj)
        {
            return (int)(Obj * 0x10000);
        }

        /// <summary>整数を固定小数(16:16)に変換する</summary>
        /// <param name="Obj">基となる整数</param>
        /// <returns>固定小数(16:16)</returns>
        public static int ToFix(this int Obj)
        {
            return Obj << 16;
        }

        /// <summary>浮動小数を固定小数に変換する</summary>
        /// <param name="Obj">基となる浮動小数</param>
        /// <param name="Count">小数部の桁数(0&lt;=Count&lt;=32)</param>
        /// <returns>Countビット固定小数</returns>
        public static int ToFix(this float Obj, int Count)
        {
            if (Count < 0) Count = 0;
            if (Count > 32) Count = 32;

            return (int)(Obj * (1 << Count));
        }

        /// <summary>浮動小数を固定小数に変換する</summary>
        /// <param name="Obj">基となる浮動小数</param>
        /// <param name="Count">小数部の桁数(0&lt;=Count&lt;=32)</param>
        /// <returns>Countビット固定小数</returns>
        public static int ToFix(this double Obj, int Count)
        {
            if (Count < 0) Count = 0;
            if (Count > 32) Count = 32;

            return (int)(Obj * (1 << Count));
        }

        /// <summary>整数を固定小数に変換する</summary>
        /// <param name="Obj">基となる整数</param>
        /// <param name="Count">小数部の桁数(0&lt;=Count&lt;=32)</param>
        /// <returns>Countビット固定小数</returns>
        public static int ToFix(this int Obj, int Count)
        {
            if (Count < 0) Count = 0;
            if (Count > 32) Count = 32;

            return Obj << Count;
        }

        /// <summary>固定小数点表記(16:16)の小数部のみを返す</summary>
        /// <param name="Obj">基となる固定小数</param>
        /// <returns>小数部を表す整数</returns>
        public static int fPart(this int Obj)
        {
            return Obj & 0xFFFF;
        }

        /// <summary>固定小数点表記(16:16)の小数部のみを浮動小数で返す</summary>
        /// <param name="Obj">基となる固定小数</param>
        /// <returns>小数部を表す浮動小数</returns>
        public static double fPartToDouble(this int Obj)
        {
            return (double)(Obj & 0xFFFF) / (double)0x10000;
        }

        /// <summary>固定小数点表記(16:16)の整数部のみを返す</summary>
        /// <param name="Obj">基となる固定小数ト</param>
        /// <returns>整数部を表す整数</returns>
        public static int iPart(this int Obj)
        {
            return Obj >> 16;
        }

        /// <summary>固定小数点表記(16:16)の小数部を切り捨てた値を返す</summary>
        /// <param name="Obj">基となる固定小数</param>
        /// <returns>小数部を切り捨てた値</returns>
        public static int Floor(this int Obj)
        {
            return Obj & unchecked((int)0xFFFF0000);
        }

        /// <summary>固定小数点表記(16:16)の小数部を切り上げた値を返す</summary>
        /// <param name="Obj">基となる固定小数</param>
        /// <returns>小数部を切り上げた値</returns>
        public static int Ceiling(this int Obj)
        {
            return (Obj & unchecked((int)0xFFFF0000)) + ((Obj & 0xFFFF) != 0 ? 0x10000 : 0);
        }

        /// <summary>固定小数点表記(16:16)の小数部を256段階で返す</summary>
        /// <param name="Obj">基となる固定小数</param>
        /// <returns>小数部を表す整数</returns>
        public static byte fPartToByte(this int Obj)
        {
            return (byte)(Obj >> 8);
        }

        /// <summary>固定小数を指定した範囲内に収めた値にして返す</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        /// <returns>範囲が限定された固定小数</returns>
        public static int FixClipping(this int Obj, int Min, int Max)
        {
            Min = Min.ToFix();
            Max = Max.ToFix();

            if (Obj < Min) Obj = Min;
            if (Obj > Max) Obj = Max;

            return Obj;
        }

        /// <summary>固定小数を指定した値を最小値としてその範囲に収めて返す</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        /// <returns>範囲が限定された固定小数</returns>
        public static int FixMinClipping(this int Obj, int Min)
        {
            Min = Min.ToFix();

            if (Obj < Min) Obj = Min;

            return Obj;
        }

        /// <summary>固定小数を指定した値を最大値としてその範囲に収めて返す</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        /// <returns>範囲が限定された固定小数</returns>
        public static int FixMaxClipping(this int Obj, int Max)
        {
            Max = Max.ToFix();

            if (Obj > Max) Obj = Max;

            return Obj;
        }

        /// <summary>固定小数を指定した範囲内に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        public static void FixClipping(ref int Obj, int Min, int Max)
        {
            Min = Min.ToFix();
            Max = Max.ToFix();

            if (Obj < Min) Obj = Min;
            if (Obj > Max) Obj = Max;
        }

        /// <summary>固定小数を指定した値を最小値としてその範囲に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        public static void FixMinClipping(ref int Obj, int Min)
        {
            Min = Min.ToFix();

            if (Obj < Min) Obj = Min;
        }

        /// <summary>固定小数を指定した値を最大値としてその範囲に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        public static void FixMaxClipping(ref int Obj, int Max)
        {
            Max = Max.ToFix();

            if (Obj > Max) Obj = Max;
        }

        /// <summary>固定小数の配列を指定した範囲内に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数の配列</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        public static void FixClipping(this int[] Obj, int Min, int Max)
        {
            Min = Min.ToFix();
            Max = Max.ToFix();

            for (int i = 0; i < Obj.Length; i++)
            {
                if (Obj[i] < Min) Obj[i] = Min;
                if (Obj[i] > Max) Obj[i] = Max;
            }
        }

        /// <summary>固定小数の配列を指定した値を最小値としてその範囲に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数の配列</param>
        /// <param name="Min">この数が取り得る最小の値(整数値のみ)</param>
        public static void FixMinClipping(this int[] Obj, int Min)
        {
            Min = Min.ToFix();

            for (int i = 0; i < Obj.Length; i++)
                if (Obj[i] < Min) Obj[i] = Min;
        }

        /// <summary>固定小数の配列を指定した値を最大値としてその範囲に収める</summary>
        /// <param name="Obj">範囲を限定したい固定小数の配列</param>
        /// <param name="Max">この数が取り得る最大の値(整数値のみ)</param>
        public static void FixMaxClipping(this int[] Obj, int Max)
        {
            Max = Max.ToFix();

            for (int i = 0; i < Obj.Length; i++)
                if (Obj[i] > Max) Obj[i] = Max;
        }
        #endregion

        #region 汎用系

        #region 型変換
        /// <summary>int型をbyte配列にして返す</summary>
        /// <param name="Obj">基となるint型</param>
        /// <returns>byte配列</returns>
        public static byte[] ToBytes(this int Obj)
        {
            byte[] Value = new byte[4];
            Value[0] = (byte)(Obj >> 24);
            Value[1] = (byte)(Obj >> 16);
            Value[2] = (byte)(Obj >> 8);
            Value[3] = (byte)(Obj);
            return Value;
        }

        /// <summary>String型をbyte配列にして返す</summary>
        /// <param name="Obj">基となるString型</param>
        /// <param name="Is8ByteCode">１文字が８バイトかどうか(falseの場合は16ビットで扱う)</param>
        /// <returns>byte配列</returns>
        public static byte[] ToBytes(this String Obj, bool Is8ByteCode)
        {
            byte[] Value = new byte[Obj.Length * (Is8ByteCode ? 1 : 2)];

            for (int i = 0; i < Obj.Length; i++)
            {
                if (Is8ByteCode)
                    Value[i] = (byte)Obj[i];

                else
                {
                    Value[i * 2] = (byte)(Obj[i] >> 8);
                    Value[i * 2 + 1] = (byte)Obj[i];
                }
            }

            return Value;
        }

        /// <summary>複数のbyte配列を連結して返す</summary>
        /// <param name="Obj">先頭となるbyte配列</param>
        /// <param name="ConcatObj">さらに連結する複数のバイト配列</param>
        /// <returns>連結後のバイト配列</returns>
        public static byte[] ConcatBytes(this byte[] Obj, params byte[][] ConcatObj)
        {
            int Length = 0;

            for (int i = 0; i < ConcatObj.GetLength(0); i++)
                Length += ConcatObj[i].Length;

            byte[] Value = new byte[Obj.Length + Length];
            Obj.CopyTo(Value, 0);
            Length = Obj.Length;

            for (int i = 0; i < ConcatObj.GetLength(0); i++)
            {
                ConcatObj[i].CopyTo(Value, Length);
                Length += ConcatObj[i].Length;
            }

            return Value;
        }

        /// <summary>boolの値がtrueだったら1、falseだったら0を返す</summary>
        /// <param name="Obj">判定するbool値</param>
        /// <returns>bool値の値に変わる1か0</returns>
        public static int ToInteger(this bool Obj)
        {
            return (Obj ? 1 : 0);
        }
        #endregion

        #region 値交換・ソート
        /// <summary>2つの変数の値を交換する</summary>
        /// <typeparam name="T">交換する変数の型</typeparam>
        /// <param name="A">交換したい変数A</param>
        /// <param name="B">交換したい変数B</param>
        public static void Swap<T>(ref T A, ref T B)
        {
            T tmp = A;
            A = B;
            B = tmp;
        }

        /// <summary>2つの変数の値を交換する</summary>
        /// <typeparam name="T">交換する変数の型</typeparam>
        /// <param name="A">交換したい変数A</param>
        /// <param name="B">交換したい変数B</param>
        /// <param name="Func">交換するかどうかを判断する式 bool Func(A,B)</param>
        public static void Swap<T>(ref T A, ref T B, Func<T, T, bool> Func)
        {
            if (Func(A, B))
            {
                T tmp = A;
                A = B;
                B = tmp;
            }
        }

        /// <summary>配列の値を右にずらす</summary>
        /// <typeparam name="T">右にずらす変数の型</typeparam>
        /// <param name="ShiftObj">ずらしたい配列</param>
        /// <param name="Count">右にずらす量(0以下は何もしない)</param>
        public static void ShiftRight<T>(this T[] ShiftObj, int Count)
        {
            if (Count <= 0)
                return;

            if (Count > ShiftObj.Length) Count = ShiftObj.Length;

            for (int i = ShiftObj.Length - 1; i >= Count; i--)
                ShiftObj[i] = ShiftObj[i - Count];

            for (int i = 0; i < Count; i++)
                ShiftObj[i] = default(T);
        }

        /// <summary>配列の値を左にずらす</summary>
        /// <typeparam name="T">左にずらす変数の型</typeparam>
        /// <param name="ShiftObj">ずらしたい配列</param>
        /// <param name="Count">左にずらす量(0以下は何もしない)</param>
        public static void ShiftLeft<T>(this T[] ShiftObj, int Count)
        {
            if (Count <= 0)
                return;

            if (Count > ShiftObj.Length) Count = ShiftObj.Length;

            for (int i = Count; i < ShiftObj.Length; i++)
                ShiftObj[i - Count] = ShiftObj[i];

            for (int i = 1; i <= Count; i++)
                ShiftObj[ShiftObj.Length - i] = default(T);
        }

        /// <summary>配列の値を右にずらしてローテートさせる</summary>
        /// <typeparam name="T">右にずらす変数の型</typeparam>
        /// <param name="RotateObj">ずらしたい配列</param>
        /// <param name="Count">右にずらす量(0以下は何もしない)</param>
        public static void RotateRight<T>(this T[] RotateObj, int Count)
        {
            if (Count <= 0)
                return;

            if (Count >= RotateObj.Length) Count = Count % RotateObj.Length;

            T[] tmp = new T[Count];

            for (int i = 0; i < Count; i++)
                tmp[i] = RotateObj[RotateObj.Length - Count + i];

            for (int i = RotateObj.Length - 1; i >= Count; i--)
                RotateObj[i] = RotateObj[i - Count];

            for (int i = 0; i < Count; i++)
                RotateObj[i] = tmp[i];
        }

        /// <summary>配列の値を左にずらしてローテートさせる</summary>
        /// <typeparam name="T">左にずらす変数の型</typeparam>
        /// <param name="RotateObj">ずらしたい配列</param>
        /// <param name="Count">左にずらす量(0以下は何もしない)</param>
        public static void RotateLeft<T>(this T[] RotateObj, int Count)
        {
            if (Count <= 0)
                return;

            if (Count >= RotateObj.Length) Count = Count % RotateObj.Length;

            T[] tmp = new T[Count];

            for (int i = 0; i < Count; i++)
                tmp[i] = RotateObj[i];

            for (int i = Count; i < RotateObj.Length; i++)
                RotateObj[i - Count] = RotateObj[i];

            for (int i = 0; i < Count; i++)
                RotateObj[RotateObj.Length - Count + i] = tmp[i];
        }

        /// <summary>指定したメソッドを用いてその戻り値の並び順でソートする(ソート方法はシェルソートを使っている)</summary>
        /// <typeparam name="T">ソートしたいオブジェクトの本来の型</typeparam>
        /// <typeparam name="TCMP">比較時に使用する型</typeparam>
        /// <param name="CompareObjs">ソートしたいオブジェクト</param>
        /// <param name="func">ソートしたいオブジェクトを引数とし、ソート時に使用する戻り値を持つ複数のメソッド(最初のメソッドほど重視される)</param>
        /// <remarks><para>メソッドがひとつもない時はソートしません。</para>
        /// <example><code>
        /// <para>Func&lt;Point, double&gt; f = (Point P)=> { return P.X; };</para>
        /// <para>Func&lt;Point, double&gt; f2 = (Point P)=> { return P.Y; };</para>
        /// <para>Obj.CustomSort(f, f2); //ObjはPoint配列、Xの順にソート、同一だった場合は更にYの順にソートした事になる</para></code></example></remarks>
        public static void CustomSort<T, TCMP>(this T[] CompareObjs, params Func<T, TCMP>[] func)
            where TCMP : IComparable<TCMP>
        {
            T Data;
            int DE = CompareObjs.Length - 1;
            int DataAddr;
            int cmp;

            for (int Gap = DE >> 1; Gap > 0; Gap >>= 1)
            {
                Gap = Gap | 1;
                for (int i = 0; i < Gap; i++)
                {
                    for (int GetData = DE - Gap - i; GetData >= 0; GetData -= Gap)
                    {
                        Data = CompareObjs[GetData];
                        for (DataAddr = GetData + Gap; DataAddr <= DE; DataAddr += Gap)
                        {
                            cmp = 0;

                            for (int k = 0; (k < func.Length) && (cmp == 0); k++)
                                cmp = func[k](CompareObjs[DataAddr]).CompareTo(func[k](Data));

                            if (cmp >= 0) break;

                            CompareObjs[DataAddr - Gap] = CompareObjs[DataAddr];
                        }
                        CompareObjs[DataAddr - Gap] = Data;
                    }
                }
            }
        }

        /// <summary>指定したメソッドを用いてその戻り値の並び順でソートする(ソート方法はシェルソートを使っている)</summary>
        /// <typeparam name="T">ソートしたいオブジェクトの本来の型</typeparam>
        /// <typeparam name="TCMP">比較時に使用する型</typeparam>
        /// <param name="CompareObjs">ソートしたいオブジェクト</param>
        /// <param name="Index">ソートを始めるインデックス位置</param>
        /// <param name="Count">ソートをする要素数</param>
        /// <param name="func">ソートしたいオブジェクトを引数とし、ソート時に使用する戻り値を持つ複数のメソッド(最初のメソッドほど重視される)</param>
        /// <remarks><para>メソッドがひとつもない時はソートしません。</para>
        /// <example><code>
        /// <para>Func&lt;Point, double&gt; f = (Point P)=> { return P.X; };</para>
        /// <para>Func&lt;Point, double&gt; f2 = (Point P)=> { return P.Y; };</para>
        /// <para>Obj.CustomSort(0, 20, f, f2); //ObjはPoint配列、始めから20要素のみXの順にソート、同一だった場合は更にYの順にソートした事になる</para></code></example></remarks>
        /// <exception cref="System.ArgumentOutOfRangeException">Countがマイナスの場合、IndexかIndex + Count - 1が配列の範囲を超えていた場合に発生</exception>
        public static void CustomSort<T, TCMP>(this T[] CompareObjs, int Index, int Count, params Func<T, TCMP>[] func)
            where TCMP : IComparable<TCMP>
        {
            T Data;
            int DE = Index + Count - 1;
            int DataAddr;
            int cmp;
            if (Count < 0 || !Index.InRange(0, CompareObjs.Length - 1, DE)) throw new ArgumentOutOfRangeException("Index , Count", "Countがマイナスまたは、IndexかIndexからCountまでの相対位置が配列の範囲を超えています。");

            for (int Gap = (DE - Index) >> 1; Gap > 0; Gap >>= 1)
            {
                Gap = Gap | 1;
                for (int i = 0; i < Gap; i++)
                {
                    for (int GetData = DE - Gap - i; GetData >= Index; GetData -= Gap)
                    {
                        Data = CompareObjs[GetData];
                        for (DataAddr = GetData + Gap; DataAddr <= DE; DataAddr += Gap)
                        {
                            cmp = 0;

                            for (int k = 0; (k < func.Length) && (cmp == 0); k++)
                                cmp = func[k](CompareObjs[DataAddr]).CompareTo(func[k](Data));

                            if (cmp >= 0) break;

                            CompareObjs[DataAddr - Gap] = CompareObjs[DataAddr];
                        }
                        CompareObjs[DataAddr - Gap] = Data;
                    }
                }
            }
        }

        #endregion

        #region 比較
        /// <summary>3つ以上のオブジェクトが一致するかどうかを比較する</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="Obj3">3つ目のオブジェクト</param>
        /// <param name="CompareObjs">4つ目以降のオブジェクト</param>
        /// <returns>全てが一致したかどうか</returns>
        public static bool PluralEquals<T>(this T Obj1, T Obj2, T Obj3, params T[] CompareObjs)
            where T : IEquatable<T>
        {
            bool flag = Obj1.Equals(Obj2) && Obj2.Equals(Obj3);

            if (CompareObjs.Length > 0)
            {
                flag = flag && Obj3.Equals(CompareObjs[0]);

                if (flag == false)
                    return flag;

                for (int i = 1; i < CompareObjs.Length; i++)
                {
                    if (!CompareObjs[i - 1].Equals(CompareObjs[i]))
                    {
                        flag = false;
                        break;
                    }
                }
            }

            return flag;
        }

        /// <summary>指定したオブジェクトが他のオブジェクトと一致するかどうかを比較する</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj">他方と比較したいオブジェクト</param>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>指定したオブジェクトが他方の1つとでも一致したかどうか</returns>
        public static bool EitherEquals<T>(this T Obj, T Obj1, T Obj2, params T[] CompareObjs)
            where T : IEquatable<T>
        {
            bool flag = Obj.Equals(Obj1) || Obj.Equals(Obj2);

            if (!flag && CompareObjs.Length > 0)
            {
                for (int i = 0; i < CompareObjs.Length; i++)
                {
                    if (Obj.Equals(CompareObjs[i]))
                    {
                        flag = true;
                        break;
                    }
                }
            }

            return flag;
        }

        /// <summary>指定したオブジェクトがどのオブジェクトと一致したかをインデックスで返す</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj">他方と比較したいオブジェクト</param>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>指定したオブジェクトが一致した最初のインデックス(Obj1が0とする、不一致は-1)</returns>
        public static int EitherEqualsIndexOf<T>(this T Obj, T Obj1, T Obj2, params T[] CompareObjs)
            where T : IEquatable<T>
        {
            int index = (Obj.Equals(Obj1) ? 0 : -1);

            if (index == -1 && Obj.Equals(Obj2))
                index = 1;

            if (index == -1 && CompareObjs.Length > 0)
            {
                for (int i = 0; i < CompareObjs.Length; i++)
                {
                    if (Obj.Equals(CompareObjs[i]))
                    {
                        index = i + 2;
                        break;
                    }
                }
            }

            return index;
        }

        /// <summary>指定したオブジェクトが他の一番小さなオブジェクトと一致するかどうかを比較する</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj">他方と比較したいオブジェクト</param>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>指定したオブジェクトが一番小さな値の他のオブジェクトと一致したかどうか</returns>
        public static bool MinEquals<T>(this T Obj, T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>, IEquatable<T>
        {
            T tmp = CompareObjs.Min().Min(Obj1, Obj2);

            return Obj.Equals(tmp);
        }

        /// <summary>指定したオブジェクトが他の一番大きなオブジェクトと一致するかどうかを比較する</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj">他方と比較したいオブジェクト</param>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>指定したオブジェクトが一番大きな値の他のオブジェクトと一致したかどうか</returns>
        public static bool MaxEquals<T>(this T Obj, T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>, IEquatable<T>
        {
            T tmp = CompareObjs.Max().Max(Obj1, Obj2);

            return Obj.Equals(tmp);
        }

        /// <summary>配列の値が全て一致するかどうかを比較する</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="CompareObjs">比較する配列</param>
        /// <returns>全てが一致したかどうか(配列の要素が2つ未満の場合falseになる)</returns>
        public static bool Equals<T>(this T[] CompareObjs)
            where T : IEquatable<T>
        {
            bool flag;

            if (CompareObjs.Length > 1)
            {
                flag = true;

                for (int i = 1; i < CompareObjs.Length; i++)
                {
                    if (!CompareObjs[i - 1].Equals(CompareObjs[i]))
                    {
                        flag = false;
                        break;
                    }
                }
            }

            else
                flag = false;

            return flag;
        }

        /// <summary>指定したオブジェクトが比較対象オブジェクトと誤差範囲内に収まるかどうかを返す</summary>
        /// <param name="Obj">比較したいオブジェクト</param>
        /// <param name="CompareObj">指定したオブジェクトと比較するオブジェクト</param>
        /// <param name="PermissibleError">許容誤差、常にプラスで指定(CompareObj ± PermissibleError の範囲)</param>
        /// <returns>誤差範囲内に収まったかどうかを返す</returns>
        /// <remarks><example><code><para>X.InErrorRange(10,2); //Xが10±2の範囲に収まるかどうかを返す</para></code></example></remarks>
        public static bool InErrorRange(this int Obj, int CompareObj, int PermissibleError)
        {
            return ((CompareObj - PermissibleError) <= Obj && Obj <= (CompareObj + PermissibleError));
        }

        /// <summary>指定したオブジェクトが比較対象オブジェクトと誤差範囲内に収まるかどうかを返す</summary>
        /// <param name="Obj">比較したいオブジェクト</param>
        /// <param name="CompareObj">指定したオブジェクトと比較するオブジェクト</param>
        /// <param name="PermissibleError">許容誤差、常にプラスで指定(CompareObj ± PermissibleError の範囲)</param>
        /// <returns>誤差範囲内に収まったかどうかを返す</returns>
        /// <remarks><example><code><para>X.InErrorRange(10,2); //Xが10±2の範囲に収まるかどうかを返す</para></code></example></remarks>
        public static bool InErrorRange(this float Obj, float CompareObj, float PermissibleError)
        {
            return ((CompareObj - PermissibleError) <= Obj && Obj <= (CompareObj + PermissibleError));
        }

        /// <summary>指定したオブジェクトが比較対象オブジェクトと誤差範囲内に収まるかどうかを返す</summary>
        /// <param name="Obj">比較したいオブジェクト</param>
        /// <param name="CompareObj">指定したオブジェクトと比較するオブジェクト</param>
        /// <param name="PermissibleError">許容誤差、常にプラスで指定(CompareObj ± PermissibleError の範囲)</param>
        /// <returns>誤差範囲内に収まったかどうかを返す</returns>
        /// <remarks><example><code><para>X.InErrorRange(10,2); //Xが10±2の範囲に収まるかどうかを返す</para></code></example></remarks>
        public static bool InErrorRange(this double Obj, double CompareObj, double PermissibleError)
        {
            return ((CompareObj - PermissibleError) <= Obj && Obj <= (CompareObj + PermissibleError));
        }

        /// <summary>2つの数の符号が一致したかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致したかどうか</returns>
        public static bool SignEquals(this int Obj1, int Obj2)
        {
            return (Obj1 < 0 && Obj2 < 0) || (Obj1 > 0 && Obj2 > 0);
        }

        /// <summary>2つの数の符号が一致したかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致したかどうか</returns>
        public static bool SignEquals(this float Obj1, float Obj2)
        {
            return (Obj1 < 0 && Obj2 < 0) || (Obj1 > 0 && Obj2 > 0);
        }

        /// <summary>2つの数の符号が一致したかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致したかどうか</returns>
        public static bool SignEquals(this double Obj1, double Obj2)
        {
            return (Obj1 < 0 && Obj2 < 0) || (Obj1 > 0 && Obj2 > 0);
        }

        /// <summary>2つの数の符号が一致しないかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致しなかったかどうか</returns>
        public static bool SignDifferent(this int Obj1, int Obj2)
        {
            return (Obj1 < 0 && Obj2 > 0) || (Obj1 > 0 && Obj2 < 0);
        }

        /// <summary>2つの数の符号が一致しないかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致しなかったかどうか</returns>
        public static bool SignDifferent(this float Obj1, float Obj2)
        {
            return (Obj1 < 0 && Obj2 > 0) || (Obj1 > 0 && Obj2 < 0);
        }

        /// <summary>2つの数の符号が一致しないかどうかを返す(一方でも0が入っていたら常にfalse)</summary>
        /// <param name="Obj1">1つ目の数</param>
        /// <param name="Obj2">2つ目の数</param>
        /// <returns>2つの数の符号が一致しなかったかどうか</returns>
        public static bool SignDifferent(this double Obj1, double Obj2)
        {
            return (Obj1 < 0 && Obj2 > 0) || (Obj1 > 0 && Obj2 < 0);
        }

        /// <summary>指定した数が範囲内に存在するかどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="Obj">判定したい数</param>
        /// <param name="Min">指定範囲の最小値</param>
        /// <param name="Max">指定範囲の最大値</param>
        /// <param name="CompareObjs">同じ範囲で比較したい他の数</param>
        /// <returns>Min以上Max以下に全て収まったかどうか</returns>
        public static bool InRange<T>(this T Obj, T Min, T Max, params T[] CompareObjs)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = (Obj.CompareTo(Min) >= 0 && Obj.CompareTo(Max) <= 0 ? true : false);

            if (!flag)
                return flag;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Min) < 0 || CompareObjs[i].CompareTo(Max) > 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>指定した数が指定値以上かどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="Obj">判定したい数</param>
        /// <param name="Min">指定値</param>
        /// <param name="CompareObjs">同じ範囲で比較したい他の数</param>
        /// <returns>全てMin以上かどうか</returns>
        public static bool MoreRange<T>(this T Obj, T Min, params T[] CompareObjs)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = (Obj.CompareTo(Min) >= 0 ? true : false);

            if (!flag)
                return flag;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Min) < 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>指定した数が指定値以下かどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="Obj">判定したい数</param>
        /// <param name="Max">指定値</param>
        /// <param name="CompareObjs">同じ範囲で比較したい他の数</param>
        /// <returns>全てMax以下かどうか</returns>
        public static bool LessRange<T>(this T Obj, T Max, params T[] CompareObjs)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = (Obj.CompareTo(Max) <= 0 ? true : false);

            if (!flag)
                return flag;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Max) > 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>配列の数が全て範囲内に存在するかどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="CompareObjs">判定したい配列</param>
        /// <param name="Min">指定範囲の最小値</param>
        /// <param name="Max">指定範囲の最大値</param>
        /// <returns>Min以上Max以下に全て収まったかどうか</returns>
        public static bool InRange<T>(this T[] CompareObjs, T Min, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = true;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Min) < 0 || CompareObjs[i].CompareTo(Max) > 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>配列の数が全て指定値以上かどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="CompareObjs">判定したい配列</param>
        /// <param name="Min">指定値</param>
        /// <returns>全てMin以上かどうか</returns>
        public static bool MoreRange<T>(this T[] CompareObjs, T Min)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = true;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Min) < 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>配列の数が全て指定値以下かどうかを返す</summary>
        /// <typeparam name="T">比較するときの型</typeparam>
        /// <param name="CompareObjs">判定したい配列</param>
        /// <param name="Max">指定値</param>
        /// <returns>全てMax以下かどうか</returns>
        public static bool LessRange<T>(this T[] CompareObjs, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            bool flag = true;

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if (CompareObjs[i].CompareTo(Max) > 0)
                {
                    flag = false;
                    break;
                }
            }

            return flag;
        }

        /// <summary>2つ以上のオブジェクトを比較して並び順が最大のものを返す</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>全オブジェクト中並び順が最大のもの</returns>
        public static T Max<T>(this T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>
        {
            int index = (Obj1.CompareTo(Obj2) < 0 ? -1 : -2);

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if ((index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2)).CompareTo(CompareObjs[i]) < 0)
                    index = i;
            }

            return (index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2));
        }

        /// <summary>2つ以上のオブジェクトを比較して並び順が最小のものを返す</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>全オブジェクト中並び順が最小のもの</returns>
        public static T Min<T>(this T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>
        {
            int index = (Obj1.CompareTo(Obj2) > 0 ? -1 : -2);

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if ((index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2)).CompareTo(CompareObjs[i]) > 0)
                    index = i;
            }

            return (index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2));
        }

        /// <summary>2つ以上のオブジェクトを比較して並び順が最大のものをインデックスで返す</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>全オブジェクト中並び順が最大のもののインデックス(Obj1を0とする)</returns>
        public static int MaxIndexOf<T>(this T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>
        {
            int index = (Obj1.CompareTo(Obj2) < 0 ? -1 : -2);

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if ((index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2)).CompareTo(CompareObjs[i]) < 0)
                    index = i;
            }

            return index + 2;
        }

        /// <summary>2つ以上のオブジェクトを比較して並び順が最小のものをインデックスで返す</summary>
        /// <typeparam name="T">比較をする時の型</typeparam>
        /// <param name="Obj1">1つ目のオブジェクト</param>
        /// <param name="Obj2">2つ目のオブジェクト</param>
        /// <param name="CompareObjs">3つ目以降のオブジェクト</param>
        /// <returns>全オブジェクト中並び順が最小のもののインデックス(Obj1を0とする)</returns>
        public static int MinIndexOf<T>(this T Obj1, T Obj2, params T[] CompareObjs)
            where T : IComparable<T>
        {
            int index = (Obj1.CompareTo(Obj2) > 0 ? -1 : -2);

            for (int i = 0; i < CompareObjs.Length; i++)
            {
                if ((index >= 0 ? CompareObjs[index] : (index == -2 ? Obj1 : Obj2)).CompareTo(CompareObjs[i]) > 0)
                    index = i;
            }

            return index + 2;
        }
        #endregion

        #region ビット演算や2進数等
        /// <summary>下位ビットから数えて指定ビット数まで全てのビットが1になる数を返す</summary>
        /// <param name="Count">指定ビット数(0以下は0ビット、32を超えは32ビットに補正される)</param>
        /// <returns>指定ビット数まで全てのビットが1の数</returns>
        public static int CreateBitCount(this int Count)
        {
            if (Count <= 0)
                return 0;

            int tmp = 0;

            if (Count > 32)
                Count = 32;

            while (Count != 0)
            {
                Count--;

                tmp |= 1 << Count;
            }

            return tmp;
        }

        /// <summary>対象の数のビットを型のビット範囲で反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <returns>反転させた数</returns>
        public static byte Not(this byte Obj)
        {
            return unchecked((byte)(~Obj));
        }

        /// <summary>対象の数のビットを型のビット範囲で反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <returns>反転させた数</returns>
        public static uint Not(this uint Obj)
        {
            return (uint)(~Obj);
        }

        /// <summary>対象の数のビットを型のビット範囲で反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <returns>反転させた数</returns>
        public static int Not(this int Obj)
        {
            return ~Obj;
        }

        /// <summary>対象の数のビットをあるビット範囲のみ反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static byte Not(this byte Obj, byte Bit)
        {
            return (byte)(Bit ^ Obj);
        }

        /// <summary>対象の数のビットをあるビット範囲で反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static uint Not(this uint Obj, uint Bit)
        {
            return (uint)(Bit ^ Obj);
        }

        /// <summary>対象の数のビットをあるビット範囲で反転する</summary>
        /// <param name="Obj">反転させたい数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static int Not(this int Obj, int Bit)
        {
            return (Bit ^ Obj);
        }

        /// <summary>2つの数をあるビット範囲でOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static byte Or(this byte Obj1, byte Obj2, byte Bit)
        {
            return (byte)(Obj1 | (Obj2 & Bit));
        }

        /// <summary>2つの数をあるビット範囲でOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static uint Or(this uint Obj1, uint Obj2, uint Bit)
        {
            return (uint)(Obj1 | (Obj2 & Bit));
        }

        /// <summary>2つの数をあるビット範囲でOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static int Or(this int Obj1, int Obj2, int Bit)
        {
            return (Obj1 | (Obj2 & Bit));
        }

        /// <summary>2つの数をあるビット範囲でAND演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static byte And(this byte Obj1, byte Obj2, byte Bit)
        {
            return (byte)(Obj1 & (Obj2 | (byte)(~Bit)));
        }

        /// <summary>2つの数をあるビット範囲でAND演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static uint And(this uint Obj1, uint Obj2, uint Bit)
        {
            return (uint)(Obj1 & (Obj2 | (uint)(~Bit)));
        }

        /// <summary>2つの数をあるビット範囲でAND演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static int And(this int Obj1, int Obj2, int Bit)
        {
            return (Obj1 & (Obj2 | (~Bit)));
        }

        /// <summary>2つの数をあるビット範囲でXOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static byte Xor(this byte Obj1, byte Obj2, byte Bit)
        {
            return (byte)(Obj1 ^ (Obj2 & Bit));
        }

        /// <summary>2つの数をあるビット範囲でXOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static uint Xor(this uint Obj1, uint Obj2, uint Bit)
        {
            return (uint)(Obj1 ^ (Obj2 & Bit));
        }

        /// <summary>2つの数をあるビット範囲でXOR演算する(残りのビットはObj1のビットが残る)</summary>
        /// <param name="Obj1">1つ目の対象の数</param>
        /// <param name="Obj2">2つ目の対象の数</param>
        /// <param name="Bit">反転させたいビットまで下位から全て1にした数(CreateBitCountで作成)</param>
        /// <returns>反転させた数</returns>
        public static int Xor(this int Obj1, int Obj2, int Bit)
        {
            return (Obj1 ^ (Obj2 & Bit));
        }

        /// <summary>その数を以下で最大値となる2のべき乗の値に近似して返す</summary>
        /// <param name="Obj">対象となる数</param>
        /// <returns>近似した値</returns>
        public static int BinaryFloorApproximate(this int Obj)
        {
            int res;

            if (Obj <= 0)
                res = 0;

            else
            {
                int cnt = -1;

                while (Obj != 0)
                {
                    Obj >>= 1;
                    cnt++;
                }

                res = 1 << cnt;
            }

            return res;
        }

        /// <summary>その数以上で最小値となる2のべき乗の値に近似して返す</summary>
        /// <param name="Obj">対象となる数</param>
        /// <returns>近似した値</returns>
        public static int BinaryCeilingApproximate(this int Obj)
        {
            int res;

            if (Obj <= 0)
                res = 0;

            else
            {
                int cnt = -1;
                int tmp = Obj;

                while (Obj != 0)
                {
                    Obj >>= 1;
                    cnt++;
                }

                res = 1 << cnt;

                if (res != tmp)
                    res <<= 1;
            }

            return res;
        }

        /// <summary>現在の値の最大ビット位置を求める(最小ビットを0番目と数える)</summary>
        /// <param name="Obj">対象となる数</param>
        /// <returns>使用している最大ビットの位置(値が0の場合は-1が返る、値がマイナスの場合は常に31が返る)</returns>
        public static int MSBCount(this int Obj)
        {
            if (Obj < 0)
                return 31;

            int Count = -1;

            while (Obj != 0)
            {
                Obj >>= 1;
                Count++;
            }

            return Count;
        }

        /// <summary>現在の値の最小ビット位置を求める(最小ビットを0番目と数える)</summary>
        /// <param name="Obj">対象となる数</param>
        /// <returns>使用している最小ビットの位置(値が0の場合は-1が返る)</returns>
        public static int LSBCount(this int Obj)
        {
            if (Obj == 0)
                return -1;

            int Count = 0;
            int LSB = 1;

            while ((Obj & LSB) == 0)
            {
                LSB <<= 1;
                Count++;
            }

            return Count;
        }
        #endregion

        #region クリッピング
        /// <summary>数を指定した範囲内に収めた値にして返す</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        /// <returns>範囲が限定された数</returns>
        public static T Clipping<T>(this T Obj, T Min, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Min) < 0) Obj = Min;
            if (Obj.CompareTo(Max) > 0) Obj = Max;
            return Obj;
        }

        /// <summary>数を指定値以上に収めて返す</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <returns>範囲が限定された数</returns>
        public static T MinClipping<T>(this T Obj, T Min)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Min) < 0) Obj = Min;
            return Obj;
        }

        /// <summary>数を指定値以下に収めて返す</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        /// <returns>範囲が限定された数</returns>
        public static T MaxClipping<T>(this T Obj, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Max) > 0) Obj = Max;
            return Obj;
        }

        /// <summary>数を指定した範囲内に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        public static void Clipping<T>(ref T Obj, T Min, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Min) < 0) Obj = Min;
            if (Obj.CompareTo(Max) > 0) Obj = Max;
        }

        /// <summary>数を指定値以上に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        public static void MinClipping<T>(ref T Obj, T Min)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Min) < 0) Obj = Min;
        }

        /// <summary>数を指定値以下に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい数</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        public static void MaxClipping<T>(ref T Obj, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            if (Obj.CompareTo(Max) > 0) Obj = Max;
        }

        /// <summary>配列の値を指定した範囲内に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい配列</param>
        /// <param name="Min">この配列の値が取り得る最小の値</param>
        /// <param name="Max">この配列の値が取り得る最大の値</param>
        public static void Clipping<T>(this T[] Obj, T Min, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            for (int i = 0; i < Obj.Length; i++)
            {
                if (Obj[i].CompareTo(Min) < 0) Obj[i] = Min;
                if (Obj[i].CompareTo(Max) > 0) Obj[i] = Max;
            }
        }

        /// <summary>配列の値を指定値以上に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい配列</param>
        /// <param name="Min">この配列の値が取り得る最小の値</param>
        public static void MinClipping<T>(this T[] Obj, T Min)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            for (int i = 0; i < Obj.Length; i++)
                if (Obj[i].CompareTo(Min) < 0) Obj[i] = Min;
        }

        /// <summary>配列の値を指定値以下に収める</summary>
        /// <typeparam name="T">数の型</typeparam>
        /// <param name="Obj">範囲を限定したい配列</param>
        /// <param name="Max">この配列の値が取り得る最大の値</param>
        public static void MaxClipping<T>(this T[] Obj, T Max)
            where T : struct, IComparable, IComparable<T>, IEquatable<T>
        {
            for (int i = 0; i < Obj.Length; i++)
                if (Obj[i].CompareTo(Max) > 0) Obj[i] = Max;
        }

        /// <summary>整数が指定した上下限を越えたら逆の上下限値にして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この整数が取り得る最小の値</param>
        /// <param name="Max">この整数が取り得る最大の値</param>
        /// <returns>範囲が限定された整数</returns>
        public static int ReverseClipping(this int Obj, int Min, int Max)
        {
            if (Obj < Min) Obj = Max;
            if (Obj > Max) Obj = Min;
            return Obj;
        }

        /// <summary>整数が指定した最小値を下回ったら最大値にして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この整数が取り得る最小の値</param>
        /// <param name="Max">この整数が取り得る最大の値</param>
        /// <returns>範囲が限定された整数</returns>
        public static int ReverseMinClipping(this int Obj, int Min, int Max)
        {
            if (Obj < Min) Obj = Max;
            return Obj;
        }

        /// <summary>整数が指定した最大値を上回ったら最小値にして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この整数が取り得る最小の値</param>
        /// <param name="Max">この整数が取り得る最大の値</param>
        /// <returns>範囲が限定された整数</returns>
        public static int ReverseMaxClipping(this int Obj, int Min, int Max)
        {
            if (Obj > Max) Obj = Min;
            return Obj;
        }

        /// <summary>数を指定した範囲内でローテートして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        /// <returns>範囲が限定された数</returns>
        public static int RotateClipping(this int Obj, int Min, int Max)
        {
            if (Obj < Min)
            {
                int tmp = Max - Min;
                while (Obj >= Min)
                    Obj += tmp;
            }

            if (Obj > Max)
            {
                int tmp = Max - Min;
                while (Obj <= Max)
                    Obj -= tmp;
            }

            return Obj;
        }

        /// <summary>数を指定した範囲内でローテートして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        /// <returns>範囲が限定された数</returns>
        public static float RotateClipping(this float Obj, float Min, float Max)
        {
            if (Obj < Min)
            {
                float tmp = Max - Min;
                while (Obj >= Min)
                    Obj += tmp;
            }

            if (Obj > Max)
            {
                float tmp = Max - Min;
                while (Obj <= Max)
                    Obj -= tmp;
            }

            return Obj;
        }

        /// <summary>数を指定した範囲内でローテートして返す</summary>
        /// <param name="Obj">範囲を限定したい整数</param>
        /// <param name="Min">この数が取り得る最小の値</param>
        /// <param name="Max">この数が取り得る最大の値</param>
        /// <returns>範囲が限定された数</returns>
        public static double RotateClipping(this double Obj, double Min, double Max)
        {
            if (Obj < Min)
            {
                double tmp = Max - Min;
                while (Obj < Min)
                    Obj += tmp;
            }

            if (Obj > Max)
            {
                double tmp = Max - Min;
                while (Obj > Max)
                    Obj -= tmp;
            }

            return Obj;
        }
        #endregion

        #region その他
        /// <summary>byte配列のCRC32を求める</summary>
        /// <param name="Obj">CRCを求めるbyte配列</param>
        /// <returns>CRC32コード</returns>
        public static int GetCRC32(this byte[] Obj)
        {
            long CRC = 0xFFFFFFFFL;

            for (int i = 0; i < Obj.Length; i++)
            {
                CRC ^= Obj[i];

                for (int j = 0; j < 8; j++)
                {
                    if ((CRC & 1) != 0) CRC = (CRC >> 1) ^ 0xEDB88320L;
                    else CRC >>= 1;
                }
            }

            return (int)CRC;
        }

        /// <summary>小数部のみを返す</summary>
        /// <param name="Obj">小数部を含んだ浮動小数</param>
        /// <returns>小数部を表す浮動小数</returns>
        public static float Modf(this float Obj)
        {
            return Obj - (float)Math.Floor(Obj);
        }

        /// <summary>小数部のみを返す</summary>
        /// <param name="Obj">小数部を含んだ浮動小数</param>
        /// <returns>小数部を表す浮動小数</returns>
        public static double Modf(this double Obj)
        {
            return Obj - Math.Floor(Obj);
        }

        /// <summary>小数部を絶対値的に切り上げて返す</summary>
        /// <param name="Obj">小数を含んだ浮動小数</param>
        /// <returns>小数部を絶対値的に切り上げた浮動小数</returns>
        public static float AbsCeiling(this float Obj)
        {
            return (float)(Obj < 0.0f ? Math.Floor(Obj) : Math.Ceiling(Obj));
        }

        /// <summary>小数部を絶対値的に切り上げて返す</summary>
        /// <param name="Obj">小数を含んだ浮動小数</param>
        /// <returns>小数部を絶対値的に切り上げた浮動小数</returns>
        public static double AbsCeiling(this double Obj)
        {
            return (Obj < 0.0 ? Math.Floor(Obj) : Math.Ceiling(Obj));
        }

        /// <summary>座標値の小数部を絶対値的に切り上げて返す</summary>
        /// <param name="Obj">小数を含んだ座標</param>
        /// <returns>小数部を絶対値的に切り上げた座標</returns>
        public static Point AbsCeiling(this Point Obj)
        {
            return new Point(Obj.X < 0.0 ? Math.Floor(Obj.X) : Math.Ceiling(Obj.X), Obj.Y < 0.0 ? Math.Floor(Obj.Y) : Math.Ceiling(Obj.Y));
        }

        /// <summary>浮動小数配列内の全ての数に対して小数部を絶対値的に切り上げる</summary>
        /// <param name="Obj">小数を含んだ浮動小数配列</param>
        public static void AbsCeiling(this float[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = (float)(Obj[i] < 0.0f ? Math.Floor(Obj[i]) : Math.Ceiling(Obj[i]));
        }

        /// <summary>浮動小数配列内の全ての数に対して小数部を絶対値的に切り上げる</summary>
        /// <param name="Obj">小数を含んだ浮動小数配列</param>
        public static void AbsCeiling(this double[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = (Obj[i] < 0.0 ? Math.Floor(Obj[i]) : Math.Ceiling(Obj[i]));
        }

        /// <summary>座標配列内の全ての数に対して小数部を絶対値的に切り上げる</summary>
        /// <param name="Obj">小数を含んだ座標配列</param>
        public static void AbsCeiling(this Point[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = new Point(Obj[i].X < 0.0 ? Math.Floor(Obj[i].X) : Math.Ceiling(Obj[i].X), Obj[i].Y < 0.0 ? Math.Floor(Obj[i].Y) : Math.Ceiling(Obj[i].Y));
        }

        /// <summary>小数部を絶対値的に切り捨てて返す</summary>
        /// <param name="Obj">小数を含んだ浮動小数</param>
        /// <returns>小数部を絶対値的に切り捨てた浮動小数</returns>
        public static float AbsFloor(this float Obj)
        {
            return (float)(Obj > 0.0f ? Math.Floor(Obj) : Math.Ceiling(Obj));
        }

        /// <summary>小数部を絶対値的に切り捨てて返す</summary>
        /// <param name="Obj">小数を含んだ浮動小数</param>
        /// <returns>小数部を絶対値的に切り捨てた浮動小数</returns>
        public static double AbsFloor(this double Obj)
        {
            return (Obj > 0.0 ? Math.Floor(Obj) : Math.Ceiling(Obj));
        }

        /// <summary>小数部を絶対値的に切り捨てて返す</summary>
        /// <param name="Obj">小数を含んだ座標</param>
        /// <returns>小数部を絶対値的に切り捨てた座標</returns>
        public static Point AbsFloor(this Point Obj)
        {
            return new Point(Obj.X > 0.0 ? Math.Floor(Obj.X) : Math.Ceiling(Obj.X), Obj.Y > 0.0 ? Math.Floor(Obj.Y) : Math.Ceiling(Obj.Y));
        }

        /// <summary>浮動小数配列内の全ての数に対して小数部を絶対値的に切り捨る</summary>
        /// <param name="Obj">小数を含んだ浮動小数配列</param>
        public static void AbsFloor(this float[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = (float)(Obj[i] > 0.0f ? Math.Floor(Obj[i]) : Math.Ceiling(Obj[i]));
        }

        /// <summary>浮動小数配列内の全ての数に対して小数部を絶対値的に切り捨る</summary>
        /// <param name="Obj">小数を含んだ浮動小数配列</param>
        public static void AbsFloor(this double[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = (Obj[i] > 0.0 ? Math.Floor(Obj[i]) : Math.Ceiling(Obj[i]));
        }

        /// <summary>座標配列内の全ての数に対して小数部を絶対値的に切り捨る</summary>
        /// <param name="Obj">小数を含んだ座標配列</param>
        public static void AbsFloor(this Point[] Obj)
        {
            for (int i = 0; i < Obj.Length; i++)
                Obj[i] = new Point(Obj[i].X > 0.0 ? Math.Floor(Obj[i].X) : Math.Ceiling(Obj[i].X), Obj[i].Y > 0.0 ? Math.Floor(Obj[i].Y) : Math.Ceiling(Obj[i].Y));
        }
        #endregion

        #endregion
    }
    #endregion
}
#endregion
